Demande et reception du message de la balise de detection. La led s'allume en fonction de la distance mesurée

communication.c

@@ -0,0 +1,126 @@
+#include "pico/error.h"
+#include "pico/stdio.h"
+#include "communication.h"
+#include "messagerie.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
+    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;
+    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);
+    }
+
+    // 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;
+        if(chaîne_octets_reçus[i] == 'r' || chaîne_octets_reçus[i] == 'w'){
+            if(i+3 < index_chaine_recue){
+                message.taille_donnees = chaîne_octets_reçus[i+3];
+            }
+            for(int z=0; z<=4 + message.taille_donnees; z++ ){
+                printf("%d ", chaîne_octets_reçus[i+z]);
+            }
+            printf("\n");
+            index_fin_message = i+4 + message.taille_donnees;
+            if(index_fin_message < index_chaine_recue){
+                if(chaîne_octets_reçus[index_fin_message] == 0){
+                    message.type = chaîne_octets_reçus[i];
+                    message.id_carte = chaîne_octets_reçus[i+1];
+                    message.adresse_registre = chaîne_octets_reçus[i+2];
+                    message.taille_donnees = chaîne_octets_reçus[i+3];
+                    for(int index_donnees=0; index_donnees<message.taille_donnees; index_donnees++){
+                        message.donnees[index_donnees] = chaîne_octets_reçus[i + 4 + index_donnees];
+                    }
+                    i = index_fin_message;
+                    fin_message = index_fin_message;
+                    index_fin_message = i;
+                    messagerie_put_message(message);
+                }
+            }
+        }
+        if(chaîne_octets_reçus[i] == 'd'){
+        }
+        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;
+                }
+            }
+        }
+    }
+
+    // Mettre à jour l'index de lecture du tampon tournant
+    augmente_index(&(com_reception_buffer.index_tampon_lecture), fin_message);
+
+}

communication.h

@@ -0,0 +1,3 @@
+
+void communication_reception_message();
+void communication_init();

main.c

@@ -29,9 +29,10 @@ void envoie_structure(const void * donnees, size_t size){
 	const unsigned char *byte;
 	for ( byte = donnees; size--; ++byte )                                     
 	{   
-		printf("%02X ", *byte);
+		putchar(*byte);
+		//printf("%2X ", *byte);
 	}   
-	putchar('\n');
+	//printf("\n");
 }
 
 void main(void)
@@ -43,9 +44,8 @@ void main(void)
 	struct message_t message;
 	struct message_requete_t message_requete_detection;
 	unsigned char message_binaire[100];
-	unsigned char message_requete_detection[10];
 
-	message_requete_detection.type = 'r';
+	message_requete_detection.type = 'd';
 	message_requete_detection.id_carte = 'D';
 	message_requete_detection.adresse_registre = 0;
 	message_requete_detection.taille_donnees = 19;
@@ -84,17 +84,19 @@ void main(void)
 
 	temps_message_detection = get_absolute_time();
 
+	communication_init();
+
 	while(1){
 
 		if(get_absolute_time() - temps_message_detection > MESSAGE_TIMEOUT_US){
 			envoie_structure(&message_requete_detection, sizeof(message_requete_detection) );
 			temps_message_detection = get_absolute_time();
 		}
-
+		
 		start_time_us = get_absolute_time();
-		envoie_donnees(message_binaire, 10);
+		//envoie_donnees(message_binaire, 10);
 		current_time_us = get_absolute_time();
-		printf(">temps:%lld\n", current_time_us - start_time_us);
+		//printf(">temps:%lld\n", current_time_us - start_time_us);
 
 		start_time_us = get_absolute_time();
 		communication_reception_message();
@@ -102,6 +104,7 @@ void main(void)
 			message = messagerie_get_message();
 			if(message.type == 'r'){
 				if(message.id_carte == 'D'){
+					temps_message_detection = get_absolute_time();
 					if(message.donnees[1] > 0 && message.donnees[1] < 30){
 						gpio_put(PICO_DEFAULT_LED_PIN, 1);
 					}else{
@@ -115,8 +118,7 @@ void main(void)
 		putchar('\n');
 		printf(">temps:%lld\n", current_time_us - start_time_us);
 		sleep_ms(50);
-
+		
-
 	}
 }
 

messagerie.c

@@ -0,0 +1,26 @@
+#include "messagerie.h"
+
+#define NB_MAX_MESSAGE 30
+
+int index_message=0;
+struct message_t message_liste[NB_MAX_MESSAGE];
+
+/// @brief Renvoi 1 si des message sont disponibles
+/// @return 
+bool messagerie_message_disponible(){
+  return (index_message != 0);
+}
+
+/// @brief Renvoi un message à traiter, à n'appeler que si message_disponible() renvoie 1
+/// @return Message
+struct message_t messagerie_get_message(){
+  index_message = index_message - 1;
+  return message_liste[index_message];
+}
+
+void messagerie_put_message(struct message_t message){
+  if(index_message < NB_MAX_MESSAGE-1){
+    message_liste[index_message] = message;
+    index_message = index_message + 1;
+  }
+}

messagerie.h

@@ -0,0 +1,24 @@
+#include "pico/stdlib.h"
+
+#define MESSAGE_TIMEOUT_US 10000
+
+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];
+};
+
+struct message_requete_t{
+  uint8_t type;
+  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 fin_de_message;
+};
+
+
+bool messagerie_message_disponible();
+struct message_t messagerie_get_message();
+void messagerie_put_message(struct message_t message);