2026-Propulsion/communication.c

#include "pico/error.h"
#include <stdio.h>
#include "communication.h"
#include "messagerie.h"
#include "tusb.h"

#define TAMPON_TAILLE 1020

struct com_reception_buffer_t{
    char tampon[TAMPON_TAILLE];     // Tampon tournant - 1er niveau de tampon
    unsigned int index_tampon_ecriture, index_tampon_lecture;
};

struct com_reception_buffer_t com_reception_buffer;


void communication_init(){
    com_reception_buffer.index_tampon_ecriture=0;
    com_reception_buffer.index_tampon_lecture=0;
}

/// @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;
    }
}

/// @brief Vérifie si des caractères ont été reçu par la liaison série
/// et analyse si un message valide a été reçu.
void communication_reception_message(){
    int input_char;
    int chaîne_octets_reçus[TAMPON_TAILLE];
    unsigned int index_chaine_recue;
    unsigned int index_tampon;
    struct message_t message;
    // Si un caractère est reçu, ajout du caractère au tampon tournant

    /// TODO: Tester le code suivant à la place de while get_char();
    /*
    char nb_recu=0;
    if(tud_cdc_available()){
        char tampon_usb[128];
        nb_recu = tud_cdc_read(tampon_usb, 128);
        // copie dans le tampon tournant
        for(int i=0; i<nb_recu; i++){
            input_char = tampon_usb[i];
            com_reception_buffer.index_tampon_ecriture++;
            if(com_reception_buffer.index_tampon_ecriture >= TAMPON_TAILLE){
                com_reception_buffer.index_tampon_ecriture = 0;
            }
            com_reception_buffer.tampon[com_reception_buffer.index_tampon_ecriture] = input_char;
        }
    }*/
    
    input_char = stdio_getchar_timeout_us(0);
    while(input_char != PICO_ERROR_TIMEOUT){
        com_reception_buffer.index_tampon_ecriture++;
        if(com_reception_buffer.index_tampon_ecriture >= TAMPON_TAILLE){
            com_reception_buffer.index_tampon_ecriture = 0;
        }
        com_reception_buffer.tampon[com_reception_buffer.index_tampon_ecriture] = input_char;

        // Caractère suivant ?
        input_char = stdio_getchar_timeout_us(0);
    }

    // Copie du tampon tournant dans une chaine
    // Parce que c'est plus simple à traiter
    index_chaine_recue = 0;
    index_tampon = com_reception_buffer.index_tampon_lecture;
    if(index_tampon != com_reception_buffer.index_tampon_ecriture){
        while(index_tampon != com_reception_buffer.index_tampon_ecriture){
            chaîne_octets_reçus[index_chaine_recue] = com_reception_buffer.tampon[index_tampon];
            index_chaine_recue++;
            increment_index(&index_tampon);
        }
        chaîne_octets_reçus[index_chaine_recue] = com_reception_buffer.tampon[index_tampon];
        index_chaine_recue++;
        increment_index(&index_tampon);
    }

    // Traitement 
    // Si on trouve le début du message
    // Si on trouve la taille du message
    // Si le caractère de fin est bien à la fin du message
    int fin_message = 0;
    for(int i=0; i<index_chaine_recue; i++){
        int index_fin_message = 0;
        // Com v2
        // OxFF OxFF <taille> ... ... <fin (0x00)>
        if(i + 2 < index_chaine_recue){
            // Test début message
            if(chaîne_octets_reçus[i] == 0xFF && chaîne_octets_reçus[i+1] == 0xFF){
                //printf("Debut message: 0xFF 0xFF\n");
                // Taille du message (sans l'entête)
                uint8_t offset = chaîne_octets_reçus[i+2];
                if(i + 2 + offset < index_chaine_recue){
                    // printf("Message totalement reçu, taille %d\n", offset);
                    // Test fin message
                    if(chaîne_octets_reçus[i + 2 + offset] == 0x00){
                        // printf("Fin message OK\n");
                        // Lecture du message
                        message.type = 'b'; // Message binaire (par opposition à un message Texte)
                        message.taille_donnees = offset - 1;
                        for(int index_donnees = 0; index_donnees < message.taille_donnees; index_donnees++){
                            message.donnees[index_donnees] = chaîne_octets_reçus[index_donnees + i + 3];
                        }
                        fin_message = i + 2 + offset;
                        messagerie_put_message(message);
                    }else{
                        // printf("Fin message NOK, attendu 0x00, recu %x\n", chaîne_octets_reçus[i + 2 + offset]);
                    }
                }
            }
        }
        if(chaîne_octets_reçus[i] == '>'){
            message.type = chaîne_octets_reçus[i];
            message.taille_donnees=0;
            while(message.taille_donnees + i  < index_chaine_recue){
                message.donnees[message.taille_donnees] = chaîne_octets_reçus[i+message.taille_donnees];
                if(message.donnees[message.taille_donnees] == '\n'){
                    i = i + message.taille_donnees; 
                    message.taille_donnees++;
                    message.donnees[message.taille_donnees] = '\0';
                    messagerie_put_message  (message);
                    fin_message = i;
                    break;
                }
                message.taille_donnees++;
            }
        }
    }

    // Mettre à jour l'index de lecture du tampon tournant
    augmente_index(&(com_reception_buffer.index_tampon_lecture), fin_message);

}