2026-USB-Maitre/log.c

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