Log des messages USB sur la carte SD fonctionnel

.vscode/c_cpp_properties.json

@@ -6,6 +6,7 @@
             "${workspaceFolder}/build/generated/pico_base",
             "${env:PICO_SDK_PATH}/src/**/include",
             "${env:PICO_SDK_PATH}/lib/**/src",
+            "${env:PICO_SDK_PATH}/lib/tinyusb/hw",
             "${workspaceFolder}/lib/FatFs/source",
             "${workspaceFolder}/lib/sd_driver"
             

.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Pico Debug (Cortex-Debug with external OpenOCD)",
+            "cwd": "${workspaceRoot}",
+            "executable": "debug/Modele_RPiPico.elf",
+            "request": "launch",
+            "type": "cortex-debug",
+            "servertype": "external",
+            "gdbTarget": "localhost:3333",
+            "gdbPath": "gdb-multiarch",
+            "device": "RP2040",
+            "svdFile": "${env:PICO_SDK_PATH}/src/rp2040/hardware_regs/RP2040.svd",
+            "runToEntryPoint": "main",
+            // Fix for no_flash binaries, where monitor reset halt doesn't do what is expected
+            // Also works fine for flash binaries
+            "overrideLaunchCommands": [
+                "monitor reset init",
+                "load debug/Modele_RPiPico.elf"
+            ]
+        },
+    ]
+}

.vscode/settings.json

@@ -14,6 +14,7 @@
         "sd_card.h": "c",
         "rp2040_sdio.h": "c",
         "util.h": "c",
-        "stddef.h": "c"
+        "stddef.h": "c",
+        "log_usb.h": "c"
     }
 }

.vscode/tasks.json

@@ -7,7 +7,17 @@
             "problemMatcher": [],
             "group": {
                 "kind": "build",
-                "isDefault": true
+                "isDefault": false
+            }
+        },
+        {
+            "type": "shell",
+            "command": "cd build; cmake ../ -DLOG=1; make Flash",
+            "label": "Flash with LOG=1",
+            "problemMatcher": [],
+            "group": {
+                "kind": "build",
+                "isDefault": false
             }
         },
         {

CMakeLists.txt

@@ -22,6 +22,9 @@ target_sources(host_cdc_msc_hid PUBLIC
         cdc_app.c
         diskio_USB.c
         diskio_SDIO.c
+        com_usb.c
+        log.c
+        messagerie.c
         lib/FatFs/source/ff.c
         lib/FatFs/source/ffsystem.c
         lib/FatFs/source/diskio.c
@@ -75,3 +78,5 @@ add_custom_target(Flash
     DEPENDS host_cdc_msc_hid
     COMMAND sudo picotool load -f ${PROJECT_BINARY_DIR}/host_cdc_msc_hid.uf2
 )
+
+add_definitions(-DPICO_STDIO_ENABLE_CRLF_SUPPORT=0)

cdc_app.c

@@ -26,6 +26,12 @@
 
 #include "tusb.h"
 #include "bsp/board_api.h"
+#include "messagerie.h"
+#include "com_usb.h"
+#include "log.h"
+#include <stdio.h>
+
+volatile bool in_transfert_cb = 0;
 
 size_t get_console_inputs(uint8_t* buf, size_t bufsize) {
   size_t count = 0;
@@ -40,6 +46,58 @@ size_t get_console_inputs(uint8_t* buf, size_t bufsize) {
   return count;
 }
 
+void traiter_les_messages(uint8_t idx, struct message_t message){
+  // Debug
+  char message_en_clair[1024];
+  message_to_string(message, message_en_clair);
+  log_event(message_en_clair);
+
+  if(message.type == '>'){
+    char message_en_clair[1024];
+    message_to_string(message, message_en_clair);
+    printf("%s\n", message_en_clair);
+  }
+
+  if(message.type == 'r'){
+    // Reception de données
+    set_carte_id(idx, message.id_carte);
+    struct log_buffer_t * log_buffer = get_buffer(idx);
+    for(int i=0; i<message.taille_donnees; i++){
+      log_buffer->tampon_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]);
+  }
+
+  if(message.type == 'd'){
+    struct message_t message_emis;
+    char message_binaire[64];
+    uint32_t taille_message;
+    // Demande de données
+    uint8_t idx_lecture = get_carte_idx(message.id_carte);
+
+    if(idx_lecture == INVALID_ID){
+      printf("Erreur, no idx found\n");
+      return;
+    }
+    struct log_buffer_t * log_buffer = get_buffer(idx_lecture);
+    
+    message_emis.type = 'r';
+    message_emis.id_carte = message.id_carte;
+    message_emis.adresse_registre = message.adresse_registre;
+    message_emis.taille_donnees = message.taille_donnees;
+    memcpy(message_emis.donnees, &(log_buffer->tampon_echange[message.adresse_registre]), message.taille_donnees);
+    
+    taille_message = message_prepare_for_usb(message_emis, message_binaire);
+    
+    tuh_cdc_write(idx, message_binaire, taille_message);
+
+  }
+
+}
+
 void cdc_app_task(void) {
   uint8_t buf[64 + 1]; // +1 for extra null character
   uint32_t const bufsize = sizeof(buf) - 1;
@@ -48,6 +106,7 @@ void cdc_app_task(void) {
   buf[count] = 0;
 
   // loop over all mounted interfaces
+  // Envoi des données
   for (uint8_t idx = 0; idx < CFG_TUH_CDC; idx++) {
     if (tuh_cdc_mounted(idx)) {
       // console --> cdc interfaces
@@ -57,6 +116,23 @@ void cdc_app_task(void) {
       }
     }
   }
+  // Analyse des données reçues lorsque la callback a été appelée
+  for (uint8_t idx = 0; idx < CFG_TUH_CDC; idx++) {
+    if (tuh_cdc_mounted(idx)) {
+      struct message_t message;
+      char chaine[1024];
+      char texte_log[255];
+      unsigned int position_chaine = 0, position_sous_chaine;
+
+      com_analyse(idx);
+      while(message_disponible()){
+        message = get_message();
+        traiter_les_messages(idx, message); 
+      }
+
+    }
+  }
+
 }
 
 //--------------------------------------------------------------------+
@@ -65,6 +141,11 @@ void cdc_app_task(void) {
 
 // Invoked when received new data
 void tuh_cdc_rx_cb(uint8_t idx) {
+  if(in_transfert_cb){
+    printf("already processing data\n");
+    return;
+  }
+  in_transfert_cb = 1;
   uint8_t buf[64 + 1]; // +1 for extra null character
   uint32_t const bufsize = sizeof(buf) - 1;
 
@@ -72,7 +153,9 @@ void tuh_cdc_rx_cb(uint8_t idx) {
   uint32_t count = tuh_cdc_read(idx, buf, bufsize);
   buf[count] = 0;
 
-  printf("%s", (char*) buf);
+  com_add(idx, buf, count);
+  
+  in_transfert_cb = 0;
 }
 
 // Invoked when a device with CDC interface is mounted
@@ -81,8 +164,9 @@ void tuh_cdc_mount_cb(uint8_t idx) {
   tuh_itf_info_t itf_info = {0};
   tuh_cdc_itf_get_info(idx, &itf_info);
 
-  printf("CDC Interface is mounted: address = %u, itf_num = %u\r\n", itf_info.daddr,
-         itf_info.desc.bInterfaceNumber);
+  printf("CDC Interface is mounted: address = %u, itf_num = %u, idx = %u\r\n", itf_info.daddr,
+         itf_info.desc.bInterfaceNumber, 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
@@ -106,4 +190,6 @@ 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);
+
+  com_destroy(idx);
 }

com_usb.c

@@ -0,0 +1,228 @@
+#include <string.h>
+#include "pico/platform/panic.h"
+#include "pico/stdlib.h"
+#include "messagerie.h"
+#include "com_usb.h"
+#include <stdio.h>
+
+
+#define TAMPON_TAILLE 1020
+
+struct log_buffer_t log_buffer[NB_MAX_CDC_CONNEXION];
+
+/// @brief Affecte l'id de la carte à une connexion CDC.
+/// @param idx 
+/// @param carte_id 
+void set_carte_id(uint8_t idx, uint8_t carte_id){
+    struct log_buffer_t * p_log_bufffer;
+    p_log_bufffer = get_buffer(idx);
+    p_log_bufffer->carte_id = carte_id;
+}
+
+/// @brief Obtient la connexion CDC à partir de l'id de la carte.
+/// @param id_carte 
+/// @return idx pour établir la connexion CDC, INVALID_ID si non trouvé.
+uint8_t get_carte_idx(uint8_t id_carte){
+    for(int i=0; i<NB_MAX_CDC_CONNEXION; i++){
+        if(log_buffer[i].carte_id == id_carte){
+            return log_buffer[i].idx;
+        }
+    }
+    printf("IDX not found - carte_id: %d\n", id_carte);
+    return INVALID_ID;
+}
+
+struct log_buffer_t * get_buffer(const char idx){
+    for (int i=0; i<NB_MAX_CDC_CONNEXION; i++){
+        if(log_buffer[i].idx == idx){
+            return &(log_buffer[i]);
+        }
+    }
+    /// TODO: panic ?
+    panic("Buffer IDX not found: %d\n", idx);
+    return NULL;
+}
+
+/// @brief Initialisation des structure de reception des données USB-CDC
+void com_init(){
+    for (int i=0; i<NB_MAX_CDC_CONNEXION; i++){
+        log_buffer[i].idx = INVALID_ID;
+        log_buffer[i].carte_id = INVALID_ID;
+        log_buffer[i].index_tampon_ecriture = 0;
+        log_buffer[i].index_tampon_lecture = 0;
+    }
+}
+
+/// @brief Affectation des tampons de reception à une liaison USB-CDC
+/// @param idx : 
+void com_create(const char idx){
+    for (int i=0; i<NB_MAX_CDC_CONNEXION; i++){
+        if(log_buffer[i].idx == INVALID_ID){
+            log_buffer[i].idx = idx;
+            log_buffer[i].carte_id = INVALID_ID;
+            log_buffer[i].index_tampon_ecriture = 0;
+            log_buffer[i].index_tampon_lecture = 0;
+            return;
+        }
+    }
+    panic("Creation impossible: idx: %d\n", idx);
+}
+
+void com_destroy(const char idx){
+    struct log_buffer_t * p_log_bufffer;
+    p_log_bufffer = get_buffer(idx);
+    p_log_bufffer->idx = INVALID_ID;
+    printf("Destruction: idx: %d\n", idx);
+}
+
+/// @brief Ajoute les données reçu au tampon tournant
+/// @param idx Numéro de la liaison CDC
+/// @param buffer Pointeur vers les données
+/// @param buffer_size Taille des données
+void com_add(const char idx, const char * buffer, uint16_t buffer_size){
+    struct log_buffer_t * log_buffer;
+    log_buffer = get_buffer(idx);
+
+    for(int i=0; i<buffer_size; i++){
+        log_buffer->index_tampon_ecriture = log_buffer->index_tampon_ecriture+1;
+        if(log_buffer->index_tampon_ecriture >= TAMPON_TAILLE){
+            log_buffer->index_tampon_ecriture = 0;
+        }
+        log_buffer->tampon[log_buffer->index_tampon_ecriture] = buffer[i];
+    }
+}
+
+/// @brief Incrémente l'index du tampon tournant
+/// @param index 
+/// @return 
+void increment_index(unsigned int *index){
+    *index = 1 + *index ;
+    if((*index) >= TAMPON_TAILLE){
+        *index = 0;
+    }
+}
+
+/// @brief augmente la position l'index du tampon tournant
+/// @param index 
+/// @return 
+void augmente_index(unsigned int *index, unsigned int offset){
+    *index = offset + *index ;
+    if((*index) >= TAMPON_TAILLE){
+        *index -= TAMPON_TAILLE;
+    }
+}
+
+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);
+    start_time_us = current_time_us;
+
+    // Les données sont dans le tampon tournant
+    // Nous les copions dans une seconde mémoire pour les analyser.
+    // Si un message est trouvé :
+    // - Celui-ci est ajouté à la liste des message à traiter
+    // - Nous avançons l'index de lecture du tampon cyclique
+    // Si nous arrivons à la fin du tampon cyclique, il n'y a plus rien à récupérer.
+    enum etat_message_t{
+        ETAT_MESSAGE_DEBUT,
+        ETAT_MESSAGE_TEXTE,
+        ETAT_MESSAGE_VALIDE
+    }etat_message;
+
+    struct log_buffer_t * p_log_bufffer;
+    char chaine[TAMPON_TAILLE];
+    char affiche_message[TAMPON_TAILLE];
+    struct message_t message;
+
+    unsigned int index, index_chaine;
+    p_log_bufffer = get_buffer(idx);
+
+    index = p_log_bufffer->index_tampon_lecture;
+    index_chaine = 0;
+
+    // Copie des données
+    if(index != p_log_bufffer->index_tampon_ecriture){
+        while(index != p_log_bufffer->index_tampon_ecriture){
+            chaine[index_chaine] = p_log_bufffer->tampon[index];
+            index_chaine++;
+            increment_index(&index);
+        }
+        chaine[index_chaine] = p_log_bufffer->tampon[index];
+        index_chaine++;
+        increment_index(&index);
+    }
+    
+    // Lecture du message
+    message.type = 0;
+    message.idx = idx;
+    unsigned int fin_message = 0;
+    for(int i=0; i< index_chaine; i++){
+        unsigned int  index_fin_message;
+        switch(etat_message){
+            case ETAT_MESSAGE_DEBUT:
+                if(chaine[i] == '>'){
+                    message.type = '>';
+                    message.taille_donnees = 0;
+                    etat_message = ETAT_MESSAGE_TEXTE;
+                }
+                if(chaine[i] == 'd'){
+                    // Est-ce que nous avons reçu le message en entier ?
+                    if(i + 4 < index_chaine){
+                        if(chaine[i+4] == 0){
+                            // Message valide
+                            message.type = 'd';
+                            message.id_carte = chaine[i+1];
+                            message.adresse_registre = chaine[i+2];
+                            message.taille_donnees = chaine[i+3];
+                            i = i + 4; // On se met à la fin du message
+                            fin_message = i;
+                            put_message(message);                            
+                        }
+                    }
+                }
+                if(chaine[i] == 'r'){
+                    // Est-ce que nous avons reçu l'entête du message ?
+                    if(i + 4 < index_chaine){
+                        message.type = 'r';
+                        message.id_carte = chaine[i+1];
+                        message.adresse_registre = chaine[i+2];
+                        message.taille_donnees = chaine[i+3];
+                        index_fin_message = i + message.taille_donnees + 4;
+                        if(index_fin_message < index_chaine){
+                            if(chaine[index_fin_message] == 0){
+                                // Message valide
+                                for(int index_donnees=0; index_donnees<message.taille_donnees; index_donnees++){
+                                    message.donnees[index_donnees] = chaine[index_donnees + i + 4];
+                                }
+                                i = index_fin_message; // On se met à la fin du message 
+                                fin_message = index_fin_message;
+                                etat_message = ETAT_MESSAGE_DEBUT;
+                                
+                                put_message(message);
+                            }
+                        }
+                    }
+                }
+                break;
+            
+            case ETAT_MESSAGE_TEXTE:
+                message.donnees[message.taille_donnees] = chaine[i];
+                message.taille_donnees++;
+                if(chaine[i] == '\n'){
+                    // message valide.
+                    message.donnees[message.taille_donnees] = '\0';
+                    fin_message = i;
+                    put_message(message);
+
+                    etat_message = ETAT_MESSAGE_DEBUT;
+                }
+                break;
+
+        }
+        
+    }
+    augmente_index(&(p_log_bufffer->index_tampon_lecture), fin_message);
+    //printf("Fin com_analyse %d\n", idx);
+}

com_usb.h

@@ -0,0 +1,21 @@
+
+#define TAMPON_TAILLE 1020
+#define NB_MAX_CDC_CONNEXION 10
+#define INVALID_ID  ((char)-1)
+
+struct log_buffer_t{
+    char idx;
+    char carte_id;
+    char tampon[TAMPON_TAILLE];     // Tampon tournant - 1er niveau de tampon
+    char tampon_echange[TAMPON_TAILLE]; // Tampon contenant l'état de la carte
+    unsigned int index_tampon_ecriture, index_tampon_lecture;
+};
+
+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);

lib/FatFs/source/diskio.c

@@ -50,7 +50,6 @@ DSTATUS disk_initialize (
 {
 	DSTATUS stat;
 	int result;
-	printf("disk_initialize : %d\n", pdrv);
 	if(pdrv >= DEV_SDIO_MIN && pdrv <= DEV_SDIO_MAX){
 		SDIO_disk_initialize(pdrv - DEV_SDIO_MIN);
 		return 0; // OK

log.c

@@ -0,0 +1,203 @@
+#include <string.h>
+#include <stdio.h>
+#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);
+    }
+}
+

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);

main.c

@@ -32,6 +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
@@ -106,9 +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
+  com_init();
   tuh_init(BOARD_TUH_RHPORT);
 
   if (board_init_after_tusb) {
@@ -141,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";
@@ -161,8 +168,8 @@ int main(void) {
     led_blinking_task();
     cdc_app_task();
     hid_app_task();
-    log_to_sd(big_big_buffer);
-    log_to_usb(big_big_buffer); // à commenter pour obtenir un test juste sur la carte SD.(ou simplement ne pas brancher de clé USB)
+    //log_to_sd(big_big_buffer);
+    //log_to_usb(big_big_buffer); // à commenter pour obtenir un test juste sur la carte SD.(ou simplement ne pas brancher de clé USB)
     
   }
 }

messagerie.c

@@ -0,0 +1,106 @@
+#include <string.h>
+#include <stdio.h>
+#include "messagerie.h"
+
+#define NB_MAX_MESSAGE 30
+
+int index_message=0;
+struct message_t message_liste[NB_MAX_MESSAGE];
+
+/// @brief Renvoi 1 si des message sont disponibles
+/// @return 
+bool message_disponible(){
+  return (index_message != 0);
+}
+
+/// @brief Renvoi un message à traiter, à n'appeler que si message_disponible() renvoie 1
+/// @return Message
+struct message_t get_message(){
+  index_message = index_message - 1;
+  return message_liste[index_message];
+}
+
+void put_message(struct message_t message){
+  if(index_message < NB_MAX_MESSAGE-1){
+    message_liste[index_message] = message;
+    index_message = index_message + 1;
+  }
+}
+
+/// @brief Remplit chaine_texte avec les données du message présentées en ascii
+/// @param message structure de transfert entre les cartes
+/// @param chaine_texte doit être allouée, prévoir  64 octets. Attention ce ne sera pas suffisant dans tous les cas
+/// @return 0 si tout s'est bien passé, 1 sinon
+char message_to_string(struct message_t message, char * chaine_texte){
+  if(message.type == 'r' || message.type == 'w' || message.type == 'd'){
+    sprintf(chaine_texte, "%c: id_carte: %d, registre: %d, taille: %d", message.type, message.id_carte, message.adresse_registre, message.taille_donnees);
+
+    if(message.type == 'r' || message.type == 'w' ){
+      char value[5];
+      strcat(chaine_texte, ", données: ");
+      for(int i=0; i< message.taille_donnees; i++){
+        sprintf(value, "%d ", message.donnees[i]);
+        strcat(chaine_texte, value);
+      }
+    }
+
+    strcat(chaine_texte, "\n");
+    return 0;
+  }
+  
+  if(message.type == '>'){
+    chaine_texte[0] = '>';
+    chaine_texte[1] = '\0';
+    strcat(chaine_texte, message.donnees);
+    strcat(chaine_texte, "\n");
+    return 0;
+  }
+  return 1;
+
+}
+
+/// @brief remplit la mémoire message_binaire pour les données du message en usb
+/// @param message 
+/// @param message_binaire 
+/// @return nombre d'octet à envoyer
+uint16_t message_prepare_for_usb(struct message_t message, uint8_t * message_binaire){
+  switch (message.type)
+  {
+  case 'r':
+    message_binaire[0] = message.type;
+    message_binaire[1] = message.id_carte;
+    message_binaire[2] = message.adresse_registre;
+    message_binaire[3] = message.taille_donnees;
+    for(int i=0; i < message.taille_donnees; i++){
+      message_binaire[4+i] = message.donnees[i];
+    }
+    message_binaire[4+message.taille_donnees] = 0;
+
+    return (4 + message.taille_donnees + 1);
+    break;
+
+  case 'd':
+    message_binaire[0] = message.type;
+    message_binaire[1] = message.id_carte;
+    message_binaire[2] = message.adresse_registre;
+    message_binaire[3] = message.taille_donnees;
+    message_binaire[4] = 0;
+    return 5;
+
+  case 'w':
+    message_binaire[0] = message.type;
+    message_binaire[1] = message.id_carte;
+    message_binaire[2] = message.adresse_registre;
+    message_binaire[3] = message.taille_donnees;
+    for(int i=0; i < message.taille_donnees; i++){
+      message_binaire[4+i] = message.donnees[i];
+    }
+    message_binaire[4+message.taille_donnees] = 0;
+    return (4 + message.taille_donnees);
+    
+  default:
+    break;
+  }
+
+}
+

messagerie.h

@@ -0,0 +1,18 @@
+#include "pico/stdlib.h"
+
+struct message_t{
+  uint8_t type; // 'd' pour demande, 'r' pour une réception de données, 'w' pour écrire des données, '>' pour des logs
+  uint8_t id_carte; // Identifiant de la carte (on reprend les adresses I2C)
+  uint8_t adresse_registre; // Adresse du registre lu
+  uint8_t taille_donnees;
+  uint8_t donnees[255];
+  uint8_t idx; // numéro de la liaison CDC qui a reçu le message
+};
+
+struct message_t messagerie_read_message(const char * chaine, unsigned int * position_chaine);
+char message_to_string(struct message_t message, char * chaine_texte);
+uint16_t message_prepare_for_usb(struct message_t message, uint8_t * message_binaire);
+
+bool message_disponible(void);
+void put_message(struct message_t message);
+struct message_t get_message(void);

tusb_config.h

@@ -102,7 +102,7 @@
 #define CFG_TUH_ENUMERATION_BUFSIZE 256
 
 #define CFG_TUH_HUB                 1 // number of supported hubs
-#define CFG_TUH_CDC                 1 // CDC ACM
+#define CFG_TUH_CDC                 3 // CDC ACM
 #define CFG_TUH_CDC_FTDI            1 // FTDI Serial.  FTDI is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CP210X          1 // CP210x Serial. CP210X is not part of CDC class, only to re-use CDC driver API
 #define CFG_TUH_CDC_CH34X           1 // CH340 or CH341 Serial. CH34X is not part of CDC class, only to re-use CDC driver API