VL53L8 et com Wifi sur le même coeur

Wifi.c

@@ -43,15 +43,9 @@ int udp_receive_get_from_buffer(char* tampon){
 }
 
 void udp_receive_callback(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port){
-    printf("UDP callback !\n");
-    printf("IP: %d.%d.%d.%d, port %d\n", (addr->addr) & 0xFF, (addr->addr >>8) & 0xFF, (addr->addr >>16) & 0xFF, (addr->addr >>24)& 0xFF, port);
-    printf("Taille:%d\n", p->len);
-    printf("Contenu: ");
     for(int i=0; i < p->len; i++){
-        printf("%c", ((char*)p->payload)[i]);
         udp_receive_put_in_buffer(((char*)p->payload)[i]);
     }
-    printf("\n");
     pbuf_free(p);
 }
 
@@ -115,7 +109,7 @@ void Wifi_udp_send_data(char * message, unsigned int size){
     if (er != ERR_OK) {
         printf("Failed to send UDP packet! error=%d", er);
     } else {
-        printf("Sent packet %d\n", counter);
+        // printf("Sent packet %d\n", counter);
         counter++;
     }
 
@@ -150,7 +144,7 @@ void Wifi_udp_send_string(char * message){
     if (er != ERR_OK) {
         printf("Failed to send UDP packet! error=%d", er);
     } else {
-        printf("Sent packet %d\n", counter);
+        // printf("Sent packet %d\n", counter);
         counter++;
     }
 

communication.c

@@ -50,31 +50,15 @@ void communication_reception_message(){
     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);
+    //printf("Ajout tampon tournant\n");
     int nb_char = udp_receive_get_from_buffer(tampon_reception_udp);
-    int current_char = nb_char;
+    int current_nb_char = nb_char;
-    while(current_char > 0){
+    //printf("nb_char %d\n", nb_char);
-        input_char = tampon_reception_udp[nb_char - current_char];
+    while(current_nb_char > 0){
-        current_char--;
+        input_char = tampon_reception_udp[nb_char - current_nb_char];
-        printf("%c %d\n", input_char, input_char);
+        current_nb_char--;
         com_reception_buffer.index_tampon_ecriture++;
         if(com_reception_buffer.index_tampon_ecriture >= TAMPON_TAILLE){
             com_reception_buffer.index_tampon_ecriture = 0;
@@ -87,6 +71,7 @@ void communication_reception_message(){
 
     // Copie du tampon tournant dans une chaine
     // Parce que c'est plus simple à traiter
+    // printf("Copie, index_tampon:%d, index_tampon_ecriture:%d\n", index_tampon, com_reception_buffer.index_tampon_ecriture);
     index_chaine_recue = 0;
     index_tampon = com_reception_buffer.index_tampon_lecture;
     if(index_tampon != com_reception_buffer.index_tampon_ecriture){
@@ -99,12 +84,14 @@ void communication_reception_message(){
         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;
+    // printf("Traitement, index_chaine_recue:%d\n", index_chaine_recue);
     for(int i=0; i<index_chaine_recue; i++){
         int index_fin_message = 0;
         // Com v2

main.c

@@ -56,6 +56,9 @@ const uint32_t step_ms=1;
 #endif
 float distance1_mm=0, distance2_mm=0;
 
+volatile char memoire_vl53L8[64];
+volatile uint8_t VL53L8CX_isReady;
+
 // DEBUG
 extern float abscisse; 
 extern struct point_xyo_t point;
@@ -91,8 +94,11 @@ void main(void)
 	sleep_ms(50);
 	Wifi_udp_send_data("\x01\x02\x03\x04\x05", 5);
 	Wifi_udp_send_string("test:1\n");
-	//i2c_maitre_init();
+	
-
+#ifdef ROBOT_PROPULSION_2026
+#else
+	i2c_maitre_init();
+#endif
 	//Servomoteur_Init();
 
 	communication_init();
@@ -109,7 +115,7 @@ void main(void)
 
 	gpio_init(LED1PIN);
 	gpio_set_dir(LED1PIN, GPIO_OUT );
-	gpio_put(LED1PIN, 1);
+	//gpio_put(LED1PIN, 1);
 
 	/*
 	gpio_init(PICO_DEFAULT_LED_PIN);
@@ -118,19 +124,25 @@ void main(void)
 
 
 
-	printf("Demarrage...\n");
+	
 	
 	
 	// TODO: A remettre - quand on aura récupéré un capteur
-	if(get_identifiant() != 0){
+#ifdef ROBOT_PROPULSION_2026
-		//multicore_launch_core1(gestion_VL53L8CX);
+#else
-		//multicore_launch_core1(gestion_affichage);
+	VL53L8_init(&Dev);
-	}else{
+	sleep_ms(100);
-		//multicore_launch_core1(gestion_affichage);
+    VL53L8_lecture( &Dev, &Results); // une première lecture 
-	}
-
-
 	
+	//if(get_identifiant() != 0){
+		//multicore_launch_core1(gestion_VL53L8CX);
+	//}else{
+		//multicore_launch_core1(gestion_affichage);
+	//}
+#endif
+	gpio_put(LED1PIN, 1);
+	//printf("Demarrage...\n");
+
 
 	enum etat_trajet_t etat_trajet=TRAJET_EN_COURS;
 	struct trajectoire_t trajectoire;
@@ -138,17 +150,43 @@ void main(void)
 	//Trajet_config(TRAJECT_CONFIG_STD);
 	Trajet_config(600, 300);
 
+	float distance_obstacle;
+	
+    uint8_t status, isReady;
+
 	while(1){
 
+		status = vl53l8cx_check_data_ready(&Dev, &isReady);
+		if(status){
+			//printf(">status:%d\n", status);
+		}
+		if(isReady){
+			VL53L8_lecture( &Dev, &Results);
+			VL53L8_min_distance(Results, &distance_obstacle);
+			Trajet_set_obstacle_mm(distance_obstacle);
+			
+			for(int i=0; i<64; i++){
+				int distance_cm  = Results.distance_mm[i]/10;
+				if(distance_cm > 200){
+					distance_cm = 250;
+				}
+				memoire_vl53L8[i] = distance_cm;
+			}
+		}
+
+
+
 		
 		communication_reception_message();
-		
 		if(messagerie_message_disponible()){
+			
 			uint8_t id_carte, registre;
 			while(messagerie_message_disponible()){
 				message = messagerie_get_message();
+				
 
 				if(message.type == 'b'){
+					
 					switch(message.donnees[0]){
 						case 'r': // réception de données
 							// Reception de données
@@ -257,41 +295,47 @@ void main(void)
 							break;
 						case 'd':
 							char message_envoi_udp[500];
-							printf("Demande donnees\n");
 							// Demande de données
 							memcpy(&message_applicatif, message.donnees, message.taille_donnees);
 							// printf("id_carte:%c %d\n", message_applicatif.id_carte, message_applicatif.id_carte);
 							// printf("adresse registre:%d\n", message_applicatif.adresse_registre, message_applicatif.id_carte);
 							// printf("taille:%d\n", message_applicatif.taille_donnees, message_applicatif.taille_donnees);
+							
 							message_envoi_udp[0] = 0xFF;
 							message_envoi_udp[1] = 0xFF;
-							message_envoi_udp[2] = 'P';
+							if(message_applicatif.id_carte == 'P'){
-							message_envoi_udp[3] = message_applicatif.taille_donnees+1;
+								// Demande des données liées au déplacement
-							stdio_putchar_raw(0xFF);
+								message_envoi_udp[2] = 'P';
-							stdio_putchar_raw(0xFF);
+								message_envoi_udp[3] = message_applicatif.taille_donnees+1;
-							stdio_putchar_raw('P');
+								
-							stdio_putchar_raw(message_applicatif.taille_donnees+1);
+								for(int i=0; i<message_applicatif.taille_donnees; i++ ){
-							for(int i=0; i<message_applicatif.taille_donnees; i++ ){
+									message_envoi_udp[4+i] = memoire_echange[message_applicatif.adresse_registre + i];
-								message_envoi_udp[4+i] = memoire_echange[message_applicatif.adresse_registre + i];
+								}
-								stdio_putchar_raw(memoire_echange[message_applicatif.adresse_registre + i]);
+								message_envoi_udp[4+message_applicatif.taille_donnees] = 0x00;
+								Wifi_udp_send_data(message_envoi_udp, 4+message_applicatif.taille_donnees + 1);
+							}else if(message_applicatif.id_carte == 'V'){
+								// Demande des données liées au VL53L8
+								message_envoi_udp[2] = 'V';
+								message_envoi_udp[3] = message_applicatif.taille_donnees+1;
+								for(int i=0; i<message_applicatif.taille_donnees; i++ ){
+									message_envoi_udp[4+i] =  memoire_vl53L8[i];
+								}
+								message_envoi_udp[4+message_applicatif.taille_donnees] = 0x00;
+								Wifi_udp_send_data(message_envoi_udp, 4+message_applicatif.taille_donnees + 1);
 							}
-							message_envoi_udp[4+message_applicatif.taille_donnees] = 0x00;
-							stdio_putchar_raw(0x00);
-							stdio_putchar_raw('\n');
-							Wifi_udp_send_data(message_envoi_udp, 4+message_applicatif.taille_donnees + 1);
-							//Wifi_udp_send_string("Coucou:1\n");
 							break;
 						default:
 							//printf("Message inconnu: %d %c\n", message.donnees[0], message.donnees[0]);
 					}
+					
+							
 				}
+				
 			}
-			//printf(">temps_reception:%lld\n", current_time_us - start_time_us);
+			
-			//printf(">nb_message:%u\n",nb_message);
+			
 		}
 		
-		// Fin du match 
-		
 		if(temps_ms != Temps_get_temps_ms()){
 			if(Temps_get_temps_ms() - temps_ms > 20){
 				/// PANIC
@@ -317,10 +361,6 @@ void main(void)
 						Moteur_Stop();
 						break;
 					case 1:
-						/*
-						get_données_reçues((uint8_t *) &msg_propulsion_pwm, sizeof(msg_propulsion_pwm), REG_PROPULSION_PWM);
-						Moteur_SetVitesse(MOTEUR_A, msg_propulsion_pwm.pwm_gauche);
-						Moteur_SetVitesse(MOTEUR_B, msg_propulsion_pwm.pwm_droit);*/
 						break;
 					case 2:
 					case 3:
@@ -360,14 +400,14 @@ void main(void)
 				//printf("x_mm:%.2f, y_mm:%.2f\n", position.x_mm, position.y_mm);
 				
 				//gestion_PAMI(step_ms, &asser_pos);
-				/*if(asser_pos){
-					AsserMoteur_Gestion(step_ms);
-				}*/
 				// Récupération des valeurs pour les mettre dans la mémoire d'échange
 				// TODO
 			}
 		}
 		
+		
+		
+		
 	}
 }
 
@@ -450,14 +490,32 @@ void gestion_VL53L8CX(void){
 	sleep_ms(100);
     VL53L8_lecture( &Dev, &Results); // une première lecture 
     uint8_t status, isReady;
+	VL53L8CX_isReady = 1;
 	while(1){
 		status = vl53l8cx_check_data_ready(&Dev, &isReady);
-		if(isReady){
+		if(status){
-			VL53L8_lecture( &Dev, &Results);
+			//printf(">status:%d\n", status);
-			VL53L8_min_distance(Results, &distance_obstacle);
-			Trajet_set_obstacle_mm(distance_obstacle);
 		}
-		affichage();
+		if(isReady){
+			//printf("Ready\n");
+			VL53L8_lecture( &Dev, &Results);
+			//printf("Trajet 1\n");
+			VL53L8_min_distance(Results, &distance_obstacle);
+			//printf("Trajet 2\n");
+			Trajet_set_obstacle_mm(distance_obstacle);
+			//printf("Trajet 3\n");
+			/*
+			for(int i=0; i<64; i++){
+				//int distance_cm  = Results.distance_mm[i] / 10;
+				int distance_cm  = Results.distance_mm[i];
+				if(distance_cm > 200){
+					distance_cm = 250;
+				}
+				memoire_vl53L8[i] = distance_cm;
+			}
+			printf("VL:%3d %3d %3d %3d\n", memoire_vl53L8[0], memoire_vl53L8[1], memoire_vl53L8[2], memoire_vl53L8[3]);*/
+		}
+		//affichage();
 	}
 }
 

messagerie_applicative.c

@@ -1,7 +1,7 @@
 #include <string.h>
 #include "messagerie_applicative.h"
 
-uint8_t memoire_echange[200];
+uint8_t memoire_echange[0xFF];
 
 
 
@@ -14,11 +14,11 @@ bool mise_a_jour_trajectoire = false;
 bool mise_a_jour_config_trajet = false;
 bool mise_a_jour_cde_inv_traj = false;
 
-void get_données_reçues(uint8_t * dst, unsigned int taille, unsigned int registre){
+void get_données_reçues(uint8_t * dst, unsigned int taille, uint8_t registre){
     memcpy(dst, &(memoire_echange[registre]), taille);
 }
 
-void mise_données_dans_échange(uint8_t * source, unsigned int taille, unsigned int registre){
+void mise_données_dans_échange(uint8_t * source, unsigned int taille, uint8_t registre){
     memcpy(&(memoire_echange[registre]), source, taille);
 }
 

messagerie_applicative.h

@@ -2,8 +2,8 @@
 #include <stdbool.h>
 
 void écriture_données(unsigned int adresse, uint8_t donnée);
-void get_données_reçues(uint8_t * dst, unsigned int taille, unsigned int registre);
+void get_données_reçues(uint8_t * dst, unsigned int taille, uint8_t registre);
-void mise_données_dans_échange(uint8_t * source, unsigned int taille, unsigned int registre);
+void mise_données_dans_échange(uint8_t * source, unsigned int taille, uint8_t registre);
 
 extern uint8_t memoire_echange[];