Messages textes fonctionnels

CMakeLists.txt

@@ -23,6 +23,7 @@ target_sources(host_cdc_msc_hid PUBLIC
         diskio_USB.c
         diskio_SDIO.c
         log_usb.c
+        messagerie.c
         lib/FatFs/source/ff.c
         lib/FatFs/source/ffsystem.c
         lib/FatFs/source/diskio.c

cdc_app.c

@@ -26,11 +26,22 @@
 
 #include "tusb.h"
 #include "bsp/board_api.h"
+#include "messagerie.h"
 #include "log_usb.h"
 #include <stdio.h>
 
+#define TAMPON_TOURNANT_TAILLE 255
+#define TAMPON_TOURNANT_NB 10
+
 volatile bool in_transfert_cb = 0;
 
+struct tampon_tournant_t{
+  uint8_t id;
+  uint8_t donnees[TAMPON_TOURNANT_TAILLE];
+  uint16_t index_ecriture, index_lecture;
+} tampons_tournant[TAMPON_TOURNANT_NB];
+
+
 size_t get_console_inputs(uint8_t* buf, size_t bufsize) {
   size_t count = 0;
   while (count < bufsize) {
@@ -52,6 +63,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
@@ -61,13 +73,29 @@ 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 message_en_clair[1024];
+      char texte_log[255];
+      unsigned int position_chaine = 0, position_sous_chaine;
+      /*
       log_get(idx, chaine);
+      // Parcourir la chaine pour trouver les messages
+      messagerie_read_message(chaine, position_chaine);
+      if(message.type != 0){
+        if(!message_to_string(message, message_en_clair)){
+          printf("%s", message_en_clair);
+        }else{
+          printf("erreur dans le traitement du message\n");
+        }
+        
+      }
       if(strlen(chaine)> 0){
         printf("%s", chaine);
-      }
+      }*/
     }
   }
 
@@ -91,8 +119,8 @@ void tuh_cdc_rx_cb(uint8_t idx) {
   uint32_t count = tuh_cdc_read(idx, buf, bufsize);
   buf[count] = 0;
 
-
-  log_analyse_input_string(idx, buf, count);
+  log_add(idx, buf, count);
+  log_analyse(idx);
   in_transfert_cb = 0;
 }
 

log_usb.c

@@ -1,15 +1,20 @@
 #include <string.h>
 #include "pico/platform/panic.h"
+#include "pico/stdlib.h"
+#include "messagerie.h"
+#include <stdio.h>
 
 #define NB_MAX_CDC_CONNEXION 10
+#define TAMPON_TAILLE 1020
 #define INVALID_ID  ((char)-1)
 
 struct log_buffer_t{
     char idx;
     char copy_active;
-    char tampon[1020];
-    char log_dispo[1020];
+    char tampon[TAMPON_TAILLE];     // Tampon tournant - 1er niveau de tampon
+    char log_dispo[TAMPON_TAILLE]; // 
     unsigned int index_tampon;
+    unsigned int index_tampon_ecriture, index_tampon_lecture;
 }log_buffer[10];
 
 static struct log_buffer_t * get_buffer(const char idx);
@@ -32,6 +37,9 @@ void log_init(){
         log_buffer[i].index_tampon = 0;
         log_buffer[i].copy_active = 0;
         log_buffer[i].idx = INVALID_ID;
+        log_buffer[i].index_tampon = 0;
+        log_buffer[i].index_tampon_ecriture = 0;
+        log_buffer[i].index_tampon_lecture = 0;
     }
 }
 
@@ -53,6 +61,153 @@ void log_destroy(const char idx){
     p_log_bufffer->idx = INVALID_ID;
 }
 
+/// @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 log_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 log_analyse(const char idx){
+    // 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
+    do{
+        chaine[index_chaine] = p_log_bufffer->tampon[index];
+        index_chaine++;
+        increment_index(&index);
+    }while(index != log_buffer->index_tampon_ecriture);
+    
+    
+    // Lecture du message
+    message.type = 0;
+    unsigned int fin_message = 0;
+    for(int i=0; i< index_chaine; i++){
+        char 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;
+                            // Debug
+                            message_to_string(message, affiche_message);
+                            printf("%s\n", affiche_message);
+                            
+                        }
+                    }
+                }
+                if(chaine[i] == 'r'){
+                    // Est-ce que nous avons reçu l'entête du message ?
+                    if(i + 3 < index_chaine){
+                        message.type = 'd';
+                        message.adresse_registre = chaine[i+1];
+                        message.taille_donnees = chaine[i+2];
+                        index_fin_message = i+ message.taille_donnees + 3;
+                        if(index_fin_message < index_chaine){
+                            if(chaine[index_fin_message] == 0){
+                                // Message valide
+                                for(int j=i+3; j<index_fin_message; j++){
+                                    message.donnees[j - (i+3)] = chaine[j];
+                                }
+                                i = i + index_fin_message; // On se met à la fin du message 
+                                fin_message = index_fin_message;
+                                etat_message = ETAT_MESSAGE_DEBUT;                        
+                                // Debug
+                                message_to_string(message, affiche_message);
+                                printf("%s\n", affiche_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;
+                    message_to_string(message, affiche_message);
+                    
+                    printf("%s\n", affiche_message);
+                    etat_message = ETAT_MESSAGE_DEBUT;
+                }
+                break;
+
+        }
+        
+    }
+    augmente_index(&(p_log_bufffer->index_tampon_lecture), fin_message);
+}
+
 void log_analyse_input_string(const char idx, const char * input_data, unsigned int str_len){
     // On charge les données dans le tampon
     // Si on a un message complet, on charge dans log dispo (s'il y a la place)

log_usb.h

@@ -3,4 +3,6 @@ void log_init(void);
 void log_create(const char idx);
 void log_destroy(const char idx);
 void log_analyse_input_string(const char idx, char * input_data, unsigned int str_len);
-void log_get(const char idx, char * chaine);
+void log_get(const char idx, char * chaine);
+void log_analyse(const char idx);
+void log_add(const char idx, const char * buffer, uint16_t buffer_size);

messagerie.c

@@ -0,0 +1,112 @@
+#include <string.h>
+#include <stdio.h>
+#include "messagerie.h"
+
+
+/// @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'){
+    if(message.type == 'd' || message.type == 'w' ){
+      sprintf(chaine_texte, "%c: registre: %d, id_carte: %d, taille: %d", message.type, message.id_carte, message.taille_donnees);
+    }else if(message.type == 'r'){
+      sprintf(chaine_texte, "%c: registre: %d, taille: %d", message.type, message.taille_donnees);
+    }else{
+      return 1;
+    }
+
+    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;
+
+}
+
+
+struct message_t messagerie_read_message(const char * chaine, unsigned int * position_chaine){
+    struct message_t message;
+    unsigned int position_sous_chaine;
+    message.type = 0;
+
+    switch(chaine[*position_chaine]){
+        case '>':
+          // copier les données tant qu'on ne trouve pas un retour à la ligne ou de fin de chaine
+          position_sous_chaine = 0;
+          message.type = '>';
+          while(*position_chaine + position_sous_chaine < 1024 && position_sous_chaine < 254){
+            message.donnees[position_sous_chaine] = chaine[*position_chaine + position_sous_chaine];
+            
+            if(message.donnees[position_sous_chaine] == '\n' || message.donnees[position_sous_chaine] == '\0'){
+              break;
+            }
+            position_sous_chaine++;
+          }
+          if(message.donnees[position_sous_chaine-1] != '\0'){
+            message.donnees[position_sous_chaine] == '\0';
+          }
+          *position_chaine = *position_chaine + position_sous_chaine;
+          break;
+
+        case 'd':
+          if(*position_chaine + 4 < 1024){
+            if(chaine[*position_chaine + 4] == '\0'){
+              message.type = chaine[*position_chaine];
+              message.id_carte = chaine[*position_chaine + 1];
+              message.adresse_registre = chaine[*position_chaine + 2];
+              message.taille_donnees = chaine[*position_chaine + 3]; 
+            }
+          
+          }
+
+        case 'r':
+          if(*position_chaine + 2 < 1024){
+            // Read size
+            message.taille_donnees = chaine[*position_chaine + 2];
+            position_sous_chaine = 2 + message.taille_donnees + 1;
+            if(*position_chaine + position_sous_chaine < 1024){
+              if(chaine[*position_chaine + position_sous_chaine] == '\0'){
+                message.type = chaine[*position_chaine];
+                message.adresse_registre = chaine[*position_chaine + 1];
+                message.taille_donnees = chaine[*position_chaine + 2]; // déjà fait plus haut
+                memcpy(message.donnees, &(chaine[*position_chaine + 3]), message.taille_donnees); 
+              }
+            }
+          }
+          break;
+          
+        case 'w':
+          if(*position_chaine + 3 < 1024){
+            // Read size
+            message.taille_donnees = chaine[*position_chaine + 3];
+            position_sous_chaine = 3 + message.taille_donnees + 1;
+            if(*position_chaine + position_sous_chaine < 1024){
+              if(chaine[*position_chaine + position_sous_chaine] == '\0'){
+                message.type = chaine[*position_chaine];
+                message.id_carte = chaine[*position_chaine + 1];
+                message.adresse_registre = chaine[*position_chaine + 2];
+                message.taille_donnees = chaine[*position_chaine + 3]; // déjà fait plus haut
+                memcpy(message.donnees, &(chaine[*position_chaine + 4]), message.taille_donnees); 
+              }
+            }
+          }
+        default:
+      }
+}

messagerie.h

@@ -0,0 +1,13 @@
+#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);