Communication par message fonctionnelle avec 3 cartes: 1 hote, 2 devices mais instable

cdc_app.c

@@ -47,17 +47,19 @@ 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];
+  /*char message_en_clair[1024];
   message_to_string(message, message_en_clair);
-  printf("%s\n", message_en_clair);
+  printf("%s\n", message_en_clair);*/
+
+  if(message.type == '>'){
+    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
+    set_carte_id(idx, message.id_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];
@@ -69,22 +71,23 @@ void traiter_les_messages(uint8_t idx, struct message_t message){
     char message_binaire[64];
     uint32_t taille_message;
     // Demande de données
-    uint8_t idx_destination = get_carte_idx(message.id_carte);
+    uint8_t idx_lecture = get_carte_idx(message.id_carte);
 
-    if(idx_destination == INVALID_ID){
+    if(idx_lecture == INVALID_ID){
-      panic("no idx found\n"); // Return est peut-être suffisant
+      printf("Erreur, no idx found\n");
       return;
     }
-    struct log_buffer_t * log_buffer = get_buffer(idx_destination);
+    struct log_buffer_t * log_buffer = get_buffer(idx_lecture);
     
     message_emis.type = 'r';
+    message_emis.id_carte = message.id_carte;
     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);
+    tuh_cdc_write(idx, message_binaire, taille_message);
 
   }
 
@@ -157,8 +160,8 @@ void tuh_cdc_mount_cb(uint8_t idx) {
   tuh_itf_info_t itf_info = {0};
   tuh_cdc_itf_get_info(idx, &itf_info);
 
-  printf("CDC Interface is mounted: address = %u, itf_num = %u\r\n", itf_info.daddr,
+  printf("CDC Interface is mounted: address = %u, itf_num = %u, idx = %u\r\n", itf_info.daddr,
-         itf_info.desc.bInterfaceNumber);
+         itf_info.desc.bInterfaceNumber, idx);
   log_create(idx);
 
 #ifdef CFG_TUH_CDC_LINE_CODING_ON_ENUM

log_usb.c

@@ -28,6 +28,7 @@ uint8_t get_carte_idx(uint8_t id_carte){
             return log_buffer[i].idx;
         }
     }
+    printf("IDX not found - carte_id: %d\n", id_carte);
     return INVALID_ID;
 }
 
@@ -46,6 +47,7 @@ struct log_buffer_t * get_buffer(const char idx){
 void log_init(){
     for (int i=0; i<NB_MAX_CDC_CONNEXION; i++){
         log_buffer[i].idx = INVALID_ID;
+        log_buffer[i].carte_id = INVALID_ID;
         log_buffer[i].index_tampon_ecriture = 0;
         log_buffer[i].index_tampon_lecture = 0;
     }
@@ -135,18 +137,18 @@ void log_analyse(const char idx){
     index_chaine = 0;
 
     // Copie des données
-    do{
+    while(index != p_log_bufffer->index_tampon_ecriture){
         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;
     message.idx = idx;
     unsigned int fin_message = 0;
     for(int i=0; i< index_chaine; i++){
-        char index_fin_message;
+        unsigned int  index_fin_message;
         switch(etat_message){
             case ETAT_MESSAGE_DEBUT:
                 if(chaine[i] == '>'){
@@ -173,16 +175,17 @@ void log_analyse(const char idx){
                     // Est-ce que nous avons reçu l'entête du message ?
                     if(i + 4 < index_chaine){
                         message.type = 'r';
-                        message.adresse_registre = chaine[i+1];
+                        message.id_carte = chaine[i+1];
-                        message.taille_donnees = chaine[i+2];
+                        message.adresse_registre = chaine[i+2];
-                        index_fin_message = i+ message.taille_donnees + 3;
+                        message.taille_donnees = chaine[i+3];
+                        index_fin_message = i + message.taille_donnees + 4;
                         if(index_fin_message < index_chaine){
                             if(chaine[index_fin_message] == 0){
                                 // Message valide
-                                for(int j=i+3; j<index_fin_message; j++){
+                                for(int index_donnees=0; index_donnees<message.taille_donnees; index_donnees++){
-                                    message.donnees[j - (i+3)] = chaine[j];
+                                    message.donnees[index_donnees] = chaine[index_donnees + i + 4];
                                 }
-                                i = i + index_fin_message; // On se met à la fin du message 
+                                i = index_fin_message; // On se met à la fin du message 
                                 fin_message = index_fin_message;
                                 etat_message = ETAT_MESSAGE_DEBUT;
                                 

messagerie.c

@@ -33,13 +33,7 @@ void put_message(struct message_t message){
 /// @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: id_carte: %d, registre: %d, taille: %d", message.type, message.id_carte, message.adresse_registre, message.taille_donnees);
-      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.adresse_registre, message.taille_donnees);
-    }else{
-      return 1;
-    }
 
     if(message.type == 'r' || message.type == 'w' ){
       char value[5];
@@ -53,6 +47,7 @@ char message_to_string(struct message_t message, char * chaine_texte){
     strcat(chaine_texte, "\n");
     return 0;
   }
+  
   if(message.type == '>'){
     chaine_texte[0] = '>';
     chaine_texte[1] = '\0';
@@ -73,14 +68,15 @@ uint16_t message_prepare_for_usb(struct message_t message, uint8_t * message_bin
   {
   case 'r':
     message_binaire[0] = message.type;
-    message_binaire[1] = message.adresse_registre;
+    message_binaire[1] = message.id_carte;
-    message_binaire[2] = message.taille_donnees;
+    message_binaire[2] = message.adresse_registre;
+    message_binaire[3] = message.taille_donnees;
     for(int i=0; i < message.taille_donnees; i++){
-      message_binaire[3+i] = message.donnees[i];
+      message_binaire[4+i] = message.donnees[i];
     }
-    message_binaire[3+message.taille_donnees] = 0;
+    message_binaire[4+message.taille_donnees] = 0;
 
-    return (3 + message.taille_donnees);
+    return (4 + message.taille_donnees + 1);
     break;
 
   case 'd':