Préparation pour expédier des messages

.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"
     }
 }

cdc_app.c

@@ -45,6 +45,51 @@ 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);
+  printf("%s\n", message_en_clair);
+
+  if(message.type == 'r'){
+    // Reception de données
+    // Si les données contiennent le registre 0, nous obtenons l'identifiant de la carte
+    // 'D' pour la carte de détection
+    if(message.adresse_registre == 0){
+      set_carte_id(idx, message.donnees[0]);
+    }
+    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];
+    }
+  }
+
+  if(message.type == 'd'){
+    struct message_t message_emis;
+    char message_binaire[64];
+    uint32_t taille_message;
+    // Demande de données
+    uint8_t idx_destination = get_carte_idx(message.id_carte);
+
+    if(idx_destination == INVALID_ID){
+      panic("no idx found\n"); // Return est peut-être suffisant
+      return;
+    }
+    struct log_buffer_t * log_buffer = get_buffer(idx_destination);
+    
+    message_emis.type = 'r';
+    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_destination, 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;
@@ -68,16 +113,14 @@ void cdc_app_task(void) {
     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_analyse(idx);
       while(message_disponible()){
         message = get_message();
-        // Debug
+        traiter_les_messages(idx, message);
-        message_to_string(message, message_en_clair);
+        
-        printf("%s\n", message_en_clair);
       }
 
     }

log_usb.c

@@ -2,21 +2,36 @@
 #include "pico/platform/panic.h"
 #include "pico/stdlib.h"
 #include "messagerie.h"
+#include "log_usb.h"
 #include <stdio.h>
 
-#define NB_MAX_CDC_CONNEXION 10
+
 #define TAMPON_TAILLE 1020
-#define INVALID_ID  ((char)-1)
 
-struct log_buffer_t{
+struct log_buffer_t log_buffer[NB_MAX_CDC_CONNEXION];
-    char idx;
-    char tampon[TAMPON_TAILLE];     // Tampon tournant - 1er niveau de tampon
-    unsigned int index_tampon_ecriture, index_tampon_lecture;
-}log_buffer[NB_MAX_CDC_CONNEXION];
 
-static struct log_buffer_t * get_buffer(const char idx);
+/// @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;
+}
 
-static struct log_buffer_t * get_buffer(const char idx){
+/// @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;
+        }
+    }
+    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]);
@@ -42,6 +57,7 @@ void log_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;
@@ -155,7 +171,7 @@ void log_analyse(const char idx){
                 }
                 if(chaine[i] == 'r'){
                     // Est-ce que nous avons reçu l'entête du message ?
-                    if(i + 3 < index_chaine){
+                    if(i + 4 < index_chaine){
                         message.type = 'r';
                         message.adresse_registre = chaine[i+1];
                         message.taille_donnees = chaine[i+2];

log_usb.h

@@ -1,8 +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 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_analyse(const char idx);
-void log_add(const char idx, const char * buffer, uint16_t buffer_size);
+void log_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);

messagerie.c

@@ -64,73 +64,47 @@ char message_to_string(struct message_t message, char * chaine_texte){
 
 }
 
+/// @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.adresse_registre;
+    message_binaire[2] = message.taille_donnees;
+    for(int i=0; i < message.taille_donnees; i++){
+      message_binaire[3+i] = message.donnees[i];
+    }
+    message_binaire[3+message.taille_donnees] = 0;
 
-struct message_t messagerie_read_message(const char * chaine, unsigned int * position_chaine){
+    return (3 + message.taille_donnees);
-    struct message_t message;
+    break;
-    unsigned int position_sous_chaine;
-    message.type = 0;
 
-    switch(chaine[*position_chaine]){
+  case 'd':
-        case '>':
+    message_binaire[0] = message.type;
-          // copier les données tant qu'on ne trouve pas un retour à la ligne ou de fin de chaine
+    message_binaire[1] = message.id_carte;
-          position_sous_chaine = 0;
+    message_binaire[2] = message.adresse_registre;
-          message.type = '>';
+    message_binaire[3] = message.taille_donnees;
-          while(*position_chaine + position_sous_chaine < 1024 && position_sous_chaine < 254){
+    message_binaire[4] = 0;
-            message.donnees[position_sous_chaine] = chaine[*position_chaine + position_sous_chaine];
+    return 5;
-            
-            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':
+  case 'w':
-          if(*position_chaine + 4 < 1024){
+    message_binaire[0] = message.type;
-            if(chaine[*position_chaine + 4] == '\0'){
+    message_binaire[1] = message.id_carte;
-              message.type = chaine[*position_chaine];
+    message_binaire[2] = message.adresse_registre;
-              message.id_carte = chaine[*position_chaine + 1];
+    message_binaire[3] = message.taille_donnees;
-              message.adresse_registre = chaine[*position_chaine + 2];
+    for(int i=0; i < message.taille_donnees; i++){
-              message.taille_donnees = chaine[*position_chaine + 3]; 
+      message_binaire[4+i] = message.donnees[i];
-            }
+    }
-          
+    message_binaire[4+message.taille_donnees] = 0;
-          }
+    return (4 + message.taille_donnees);
+    
+  default:
+    break;
+  }
+
+}
 
-        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

@@ -11,6 +11,7 @@ struct message_t{
 
 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);