Log des messages USB sur la carte SD fonctionnel

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

cdc_app.c

@@ -28,6 +28,7 @@
 #include "bsp/board_api.h"
 #include "messagerie.h"
 #include "com_usb.h"
+#include "log.h"
 #include <stdio.h>
 
 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; 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]);
   }
 
@@ -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);
 }

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; i<NB_MAX_CDC_CONNEXION; i++){
         log_buffer[i].idx = INVALID_ID;
         log_buffer[i].carte_id = INVALID_ID;
@@ -55,7 +55,7 @@ void log_init(){
 
 /// @brief Affectation des tampons de reception à une liaison USB-CDC
 /// @param idx : 
-void log_create(const char 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;
@@ -68,7 +68,7 @@ void log_create(const char idx){
     panic("Creation impossible: idx: %d\n", idx);
 }
 
-void log_destroy(const char 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;
@@ -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);
 }

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

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,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";