Prise en compte du "Range status" lors de la lecture des mesures

.vscode/c_cpp_properties.json

@@ -2,6 +2,7 @@
     "env": {
         "myDefaultIncludePath": [
             "${workspaceFolder}",
+            "${workspaceFolder}/build",
             "${env:PICO_SDK_PATH}/src/./common/pico_binary_info/include",
             "${env:PICO_SDK_PATH}/src/./common/pico_base/include",
             "${env:PICO_SDK_PATH}/src/./common/pico_time/include",
@@ -73,7 +74,8 @@
             "name": "Linux",
             "intelliSenseMode": "linux-gcc-arm",
             "includePath": [
-                "${myDefaultIncludePath}"
+                "${myDefaultIncludePath}",
+                "${workspaceFolder}/build/"
             ],
             "compilerPath": "/usr/bin/arm-none-eabi-gcc",
             "cStandard": "c11",

.vscode/settings.json

@@ -2,6 +2,8 @@
     "files.associations": {
         "vl53l1x_calibration.h": "c",
         "vl53l1x_api.h": "c",
-        "i2c.h": "c"
+        "i2c.h": "c",
+        "vl53l1_platform.h": "c",
+        "vl53l1_types.h": "c"
     }
 }

CMakeLists.txt

@@ -31,7 +31,7 @@ target_link_libraries(Detection2023
   hardware_uart 
   hardware_pio 
   pico_stdlib
-
+  pico_multicore
 )
 
 pico_enable_stdio_usb(Detection2023 1)

Readme.md

@@ -17,6 +17,24 @@ La première étape de l'initialisation consiste à changer tous les capteurs d'
 
 La seconde étape consiste, pour chaque capteur, à le désactiver puis à le réactiver à l'aide du 74HC4067 et de la boche `XSHUT` du composant. Ce faisant, il reprend son adresse par défaut et il est le seul à cette adresse. Ainsi il est possible, via le bus I2C de lui attribuer une adresse unique.
 
+Communication I2C
+-----------------
+
+Avec le reste du robot, la carte communique en I2C sur le bus i2c1, se comportant comme une EPROM en utilisant le code de Valentin Milea <valentin.milea@gmail.com>, [Pico_i2c_slave](https://github.com/vmilea/pico_i2c_slave).
+
+Description de la mémoire d'échange:
+------------------------------------
+Les adresses 0 à 11 (0x0B) contiennent les distances des capteurs en centimètre. Cette distance est saturée à 200 cm.
+Les adresses 16 (0x10) à 18 (0x12) contiennent les consignes d'éclairage des LEDs:
+* 0x10 : Couleur sur 8 bits.
+* 0x11 : octet de poids fort pour le masque sélectionnant les LEDs à commander.
+* 0x12 : octet de poids faible pour le masque sélectionnant les LEDs à commander.
+
+Couleur sur 8 bits structurée ainsi : 3-3-2 (Rouge - vert - bleu).
+Le masque sur 16 bits, 1 : la led doit être piloter de la couleur indiquée, 0 la led affiche la distance.
+Valeur spéciale pour le masque : 0x00. Dans ce cas, toutes les LEDs reprennent leur fonction par défaut (affichage de la distance).
+
+
 Démo - Ne fonctionne plus
 ----
 

SelectionCapteur.c

@@ -22,10 +22,9 @@ void Selection_capteur_init(void){
 }
 
 /// @brief Désactive le capteur en question
-/// @param capteur capteur, numéroté de 1 à 12
+/// @param capteur capteur, numéroté de 0 à 11
 void Selection_capteur_select(uint32_t capteur){
     uint32_t io_value;
-    capteur = capteur - 1;
 
     io_value = 0;
     io_value |= ((capteur & 0x08) >> 3) << 2;
@@ -43,5 +42,5 @@ void Selection_capteur_init_pin_low(uint pin){
 }
 
 void Selection_capteur_deselect(){
-    Selection_capteur_select(16);
+    Selection_capteur_select(15);
 }

Tests.c

@@ -1,15 +1,31 @@
 #include "pico/stdlib.h"
+#include "pico/multicore.h"
 #include <stdio.h>
 #include "ws2812.h"
 #include "VL53L1X_Fonctions.h"
 
 void display_menu();
+void test_couleur_led();
 
 #define TEST_TIMEOUT_US 10000000
 
+
+void blink_test(void){
+    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
+    uint8_t * distance_capteur_cm = get_distance_capteur_cm();
+    while(1){
+        for(uint8_t capteur=0; capteur<12; capteur++){
+            printf(">distance%x:%d\n", capteur, distance_capteur_cm[capteur]);
+        }
+        sleep_ms(50);
+
+    }
+
+}
+
 void Tests(void){
     int answer_at_least_once=0;
-    uint8_t VL53L1X_device = 0x29;
+    uint8_t VL53L1X_device = 0x31;
     while(1){
         int keycode;
         display_menu();
@@ -30,6 +46,16 @@ void Tests(void){
             change_address(&VL53L1X_device, VL53L1X_device + 3);
             printf("New address: %d\n", VL53L1X_device);
             break;
+        case 'c':
+        case 'C':
+            printf("Affichage couleur sur LED\n");
+            test_couleur_led();
+            break;
+        case 'd':
+        case 'D':
+            printf("Reset affichage couleur sur LED\n");
+            reset_affichage_led();
+            break;
         case 'i':
         case 'I':
             printf("Initialisation des capteurs\n");
@@ -37,7 +63,26 @@ void Tests(void){
             break;
         case 'j':
         case 'J':
-            while(continuous_multiple_reading());
+            printf("Lecture continue des capteurs inutilisés.\nAppuyer sur une touche pour quitter\n");
+            multicore_launch_core1(blink_test);
+            do{
+                static uint8_t capteur_courant=0;
+                uint8_t * distance_capteur_cm = get_distance_capteur_cm();
+                keycode = getchar_timeout_us(0);
+                // Lecture des capteurs
+                if(capteur_pret(capteur_courant)){
+                    uint8_t distance_cm;
+                    if(capteur_lire_distance_cm(capteur_courant, &distance_cm)){
+                        distance_capteur_cm[capteur_courant]= distance_cm;
+                    }
+                }
+                capteur_courant++;
+                if(capteur_courant > 11){
+                    capteur_courant = 0;
+                }
+                // Affichage des distances sur les LEDs.
+                affiche_distance_sur_led(distance_capteur_cm);
+            }while(keycode == PICO_ERROR_TIMEOUT || keycode == 0);
             break;
         case 'k':
         case 'K':
@@ -45,7 +90,7 @@ void Tests(void){
             break;
         case 'l':
         case 'L':
-            while(continuous_reading(0x31));
+            while(continuous_reading(0x38));
             break;
         case 'o':
         case 'O':
@@ -65,6 +110,7 @@ void Tests(void){
 void display_menu(){
     printf("Select action :\n");
     printf("A - Change I2C address\n");
+    printf("C - Couleur Led\n");
     printf("I - Init I2C address\n");
     printf("J - Lecture distance multiple\n");
     printf("K - Arc en ciel\n");
@@ -72,3 +118,21 @@ void display_menu(){
     printf("O - Offset Calibration\n");
     printf("R - Read distance\n");
 }
+
+/// @brief Force une couleur sur une led qui ne doit pas être effacée par la distance lue par le capteur.
+/// A utiliser après l'initialisation des catpeurs et avant la lecture continue
+void test_couleur_led(){
+    unsigned int couleur, led;
+    int scanf1, scanf2;
+    printf("Choississez la led (0 - 11)\n");
+    scanf1 = scanf("%u", &led);
+    printf("Choississez la couleur (0 - 255)\n");
+    scanf2 = scanf("%u", &couleur);
+    if(scanf1 == 1 && scanf2 == 1){
+        printf("Actualisation de la led %d avec la couleur %d\n", led, couleur);
+        affiche_couleur_sur_led(couleur, led);
+    }else{
+        printf("Erreur scanf...\n");
+    }
+    ws2812_affiche_buffer();
+}

VL53L1X_Fonctions.c

@@ -1,18 +1,34 @@
 #include "pico/stdlib.h"
 #include <stdio.h>
 #include "VL53L1X_api.h"
+#include "VL53L1X_calibration.h"
 #include "VL53L1X_Fonctions.h"
 #include "SelectionCapteur.h"
 #include "ws2812.h"
 
-#define DISTANCE_TRES_LOIN_CM 120
+#define DISTANCE_TROP_LOIN_CM 200 /* Distance de saturation */
-#define DISTANCE_LOIN_CM 80
+#define DISTANCE_TRES_LOIN_CM 120 /* Seuil min. pour la couleur bleu*/
-#define DISTANCE_PROCHE_CM 14
+#define DISTANCE_LOIN_CM 80 /* Seuil min. pour la couleur verte*/
+#define DISTANCE_PROCHE_CM 15 /* Seuil entre violet et jaune*/
+
+#define NB_CAPTEURS 12
+#define ADRESSE_I2C_BASE 0x31
 
 // Stock les valeurs lues des capteurs
 uint8_t distance_capteur_cm[12];
 
 uint8_t statu_capteurs[13];
+enum {
+    MODE_DISTANCE,
+    MODE_MANUEL
+} mode_led[NB_CAPTEURS];
+
+
+uint8_t * get_distance_capteur_cm(void){
+    return distance_capteur_cm;
+}
+
+void reset_affichage_led(void);
 
 void initialise_adresses(void){
     const uint8_t tmp_i2c_adresse = 0x28;
@@ -25,8 +41,10 @@ void initialise_adresses(void){
     Selection_capteur_deselect();
     change_address(&adresse, tmp_i2c_adresse);
 
+    reset_affichage_led();
+
     // Pour chaque capteur
-    for(uint capteur=1; capteur<=12; capteur++){
+    for(uint capteur=0; capteur<NB_CAPTEURS; capteur++){
         // reset du capteur
         Selection_capteur_select(capteur);
         sleep_ms(1);
@@ -34,14 +52,14 @@ void initialise_adresses(void){
         sleep_ms(1);
         uint8_t VL53L1X_device = 0x29;
 
-        if(change_address(&VL53L1X_device, 0x30 + capteur)){
+        if(change_address(&VL53L1X_device, ADRESSE_I2C_BASE + capteur)){
-            printf("Erreur change adresse : %x => %x, capteur : %d\n", VL53L1X_device, 0x30 + capteur, capteur);
+            printf("Erreur change adresse : %x => %x, capteur : %d\n", VL53L1X_device, ADRESSE_I2C_BASE + capteur, capteur);
-            ws2812_set_buffer_rgb(0x4, 0, 0, capteur-1);
+            ws2812_set_buffer_rgb(0x4, 0, 0, capteur);
             statu_capteurs[capteur]=0;
         }else{
             if(VL53L1X_SensorInit(VL53L1X_device)){
                 // bad init
-                ws2812_set_buffer_rgb(0x4, 0, 0, capteur-1);
+                ws2812_set_buffer_rgb(0x4, 0, 0, capteur);
                 statu_capteurs[capteur]=0;
             }else{
                 // good init
@@ -52,7 +70,7 @@ void initialise_adresses(void){
                 status |= VL53L1X_SetTimingBudgetInMs(VL53L1X_device, 200);
                 if(status){
                     printf("Custom config KO, error %d\n", status);
-                    ws2812_set_buffer_rgb(0x4, 0, 0, capteur-1);
+                    ws2812_set_buffer_rgb(0x4, 0, 0, capteur);
                 }else{
                     printf("Custom config OK\n");
                 }
@@ -62,6 +80,7 @@ void initialise_adresses(void){
                     ws2812_set_buffer_rgb(0, 0x4, 0, capteur-1);
                 }else{
                     ws2812_set_buffer_rgb(0x2, 0x2, 0, capteur-1);
+                    mode_led[capteur-1]=MODE_DISTANCE;
                 }
 
                 
@@ -85,49 +104,69 @@ int change_address(uint8_t *device, uint8_t new_i2c_7bits_address){
     return status;
 }
 
-int continuous_multiple_reading(){
+/// @brief Renvoie 1 si capteur prêt
-    for(uint8_t device=0x31; device<0x31+12; device++){
+/// @param capteur : capteur à interroger, entre 0 et 11
-        if(statu_capteurs[device-0x31+1]==0){
+/// @return 1 si prêt, 0 si pas prêt, -1 si erreur
-            continue;
+int capteur_pret(uint8_t capteur){
-        }
     int status;
     uint8_t data_ready = 0;
+
+    if(statu_capteurs[capteur]==0){
+        printf("capteur non prêt:%d\n",capteur);
+        return 0;
+    }
+    status=VL53L1X_CheckForDataReady(capteur + ADRESSE_I2C_BASE, &data_ready);
+    if(status){
+        printf("CheckForDataReady KO, error %d, capteur:%x\n", status, capteur + ADRESSE_I2C_BASE);
+        return 1;
+    }
+    return data_ready;
+
+}
+
+/// @brief Lecture d'un capteur prêt.
+/// @param capteur : identifiant du capteur entre 0 et 11
+/// @return 1 si la lecture s'est bien passée, 0 sinon.
+int capteur_lire_distance_cm(uint8_t capteur, uint8_t * distance_cm){
+    int status;
     uint16_t distance_mm;
-        while(!data_ready){
+    uint8_t range_status;
-            status=VL53L1X_CheckForDataReady(device, &data_ready);
+    status=VL53L1X_GetDistance(capteur + ADRESSE_I2C_BASE, &distance_mm);
     if(status){
-                printf("CheckForDataReady KO, error %d, capteur:%x\n", status, device);
+        printf("GetDistance KO, error %d, capteur:%x\n", status, capteur + ADRESSE_I2C_BASE);
-            }
+        return 0;
     }
 
-        status=VL53L1X_GetDistance(device, &distance_mm);
+    status=VL53L1X_GetRangeStatus(capteur + ADRESSE_I2C_BASE, &range_status);
     if(status){
-            printf("GetDistance KO, error %d, capteur:%x\n", status, device);
+        printf("GetRangeStatus KO, error %d, capteur:%x\n", status, capteur + ADRESSE_I2C_BASE);
         return 0;
+    }
+
+    if(range_status == 0){
+        if(distance_mm/10 < (uint16_t) DISTANCE_TROP_LOIN_CM){
+            *distance_cm = distance_mm / 10;
         }else{
-            printf(">distance%x:%d\n", device, distance_mm);
+            *distance_cm = DISTANCE_TROP_LOIN_CM;
-            distance_capteur_cm[device-0x31] = distance_mm / 10;
+        }
+    }else{
+        *distance_cm = DISTANCE_TROP_LOIN_CM;
     }
     
-        status=VL53L1X_ClearInterrupt(device);
+    
+    status=VL53L1X_ClearInterrupt(capteur + ADRESSE_I2C_BASE);
     if(status){
-            printf("ClearInterrupt KO, error %d, capteur:%x\n", status, device);
+        printf("ClearInterrupt KO, error %d, capteur:%x\n", status, capteur + ADRESSE_I2C_BASE);
         return 0;
     }
-
-        int lettre = getchar_timeout_us(0);
-        if(lettre != PICO_ERROR_TIMEOUT && lettre != 0){
-            //return 0;
-        }
-    }
-    affiche_distance_sur_led();
     return 1;
 }
 
-void affiche_distance_sur_led(){
+void affiche_distance_sur_led(unsigned char * distance_capteur_cm){
     uint8_t distance_cm;
     uint32_t couleur;
     for(uint8_t capteur=0; capteur<12; capteur++){
+        if(mode_led[capteur] == MODE_DISTANCE){
             distance_cm = distance_capteur_cm[capteur];
             if(distance_cm == 0 ||distance_cm > DISTANCE_TRES_LOIN_CM){
                 ws2812_set_buffer_rgb(COULEUR_TRES_LOIN, capteur);
@@ -138,13 +177,26 @@ void affiche_distance_sur_led(){
             }else{
                 ws2812_set_buffer_rgb(COULEUR_TROP_PROCHE, capteur);
             }
-        
+        }
     }
     ws2812_affiche_buffer();
 }
 
+void affiche_couleur_sur_led(uint8_t couleur_8bits, uint8_t led){
+    mode_led[led] = MODE_MANUEL;
+    ws2812_set_buffer_8bits(couleur_8bits, led);
+}
+
+/// @brief Remet toutes les LEDs en mode d'affichage de la distance
+void reset_affichage_led(){
+    for(uint8_t capteur=0; capteur<12; capteur++){
+        mode_led[capteur] = MODE_DISTANCE;
+    }
+}
+
 int calibration(uint8_t device){
     uint16_t offset;
+    uint16_t x_talk;
     int status;
     uint8_t boot_state=0;
     printf("Calibration...\n");
@@ -167,6 +219,18 @@ int calibration(uint8_t device){
         printf("Offset : %d\n", offset);
 
     }
+    /* 
+    // Renvoie x_talk = 0 si la calibration se passe bien car
+    // nous n'avons pas de vitre de protection devant le capteur
+    status = VL53L1X_CalibrateXtalk(device, 1000, &x_talk);
+    if(status != 0){
+        printf("Error while calibrating : %d\n",status);
+    }else{
+        printf("xTalk : %d\n", x_talk);
+
+    }
+    */
+
     return 0;
 }
 
@@ -175,7 +239,7 @@ int continuous_reading(uint8_t device){
     uint8_t data_ready, boot_state=0;
     uint16_t distance;
 
-    printf("Reading distance...\nSend any character to quit.");
+    printf("Reading distance...\nSend any character to quit.\n");
 
     while(!boot_state){
         VL53L1X_BootState(device, &boot_state);

VL53L1X_Fonctions.h

@@ -11,11 +11,16 @@
 
 
 int continuous_multiple_reading(void);
-void affiche_distance_sur_led(void);
+int continuous_special_reading(void);
+void affiche_distance_sur_led(unsigned char *);
+void affiche_couleur_sur_led(uint8_t couleur_8bits, uint8_t led);
+void reset_affichage_led(void);
 void initialise_adresses(void);
 int change_address(uint8_t *device, uint8_t new_i2c_7bits_address);
 int calibration(uint8_t device);
 int continuous_reading(uint8_t device);
-extern uint8_t distance_capteur_cm[];
+int capteur_pret(uint8_t capteur);
+int capteur_lire_distance_cm(uint8_t capteur, uint8_t * distance_cm);
+uint8_t * get_distance_capteur_cm(void);
 
 extern uint8_t statu_capteurs[];

main.c

@@ -1,5 +1,6 @@
 #include <stdio.h>
 #include "pico/stdlib.h"
+#include "pico/multicore.h"
 #include "hardware/i2c.h"
 #include "VL53L1X_Fonctions.h"
 #include "SelectionCapteur.h"
@@ -25,13 +26,16 @@ int continuous_reading(uint8_t device);
 int calibration(uint8_t device);
 int change_address(uint8_t * device, uint8_t new_i2c_7bits_address);
 void initialise_adresses(void);
-int continuous_multiple_reading(void);
 void affiche_distance_sur_led();
 void init_sensors(void);
 
-
+uint8_t tampon_commande_led[3];
 
 #define I2C_SLAVE_ADDRESS 0x18
+#define ADRESSE_RECEPTION_DATA 0x10
+#define ADRESSE_COULEUR_LED 0x10
+#define ADRESSE_MASQUE_LED_1 0x11
+#define ADRESSE_MASQUE_LED_2 0x12
 
 static const uint I2C_SLAVE_SDA_PIN = I2C1_SDA_PIN; 
 static const uint I2C_SLAVE_SCL_PIN = I2C1_SCL_PIN;
@@ -99,9 +103,37 @@ static void setup_slave() {
 }
 
 
+void blink(void){
+    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
+    while(1){
+        printf("couleur_Led:%2x\n", tampon_commande_led[0]);
+        printf("masque_Led:%3x\n", (tampon_commande_led[1]<<8) | tampon_commande_led[2]);
+
+        for(uint8_t capteur=0; capteur<12; capteur++){
+            printf(">distance%x:%d\n", capteur, context.mem[capteur]);
+        }
+        
+        gpio_put(LED_PIN, !gpio_get(LED_PIN));
+        sleep_ms(20);
+
+    }
+
+}
+
+
 void main(void)
 {
     int status;
+    uint8_t distance_capteur_cm[12];
+
+    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
+    gpio_init(LED_PIN);
+    gpio_set_dir(LED_PIN, GPIO_OUT);
+    gpio_put(LED_PIN, 1);
+    
+    tampon_commande_led[0]=0;
+    tampon_commande_led[1]=0;
+    tampon_commande_led[2]=0;
     
     uint8_t VL53L1X_device = 0x29;
 
@@ -117,18 +149,54 @@ void main(void)
 
     //Tests();
 
+    multicore_launch_core1(blink);
+
     initialise_adresses();
+
+    uint8_t capteur_courant=0;
     while(1){
         // Lecture des capteurs
-        continuous_multiple_reading();
+        if(capteur_pret(capteur_courant)){
+            uint8_t distance_cm;
+            if(capteur_lire_distance_cm(capteur_courant, &distance_cm)){
+                distance_capteur_cm[capteur_courant]= distance_cm;
+            }
+        }
+        capteur_courant++;
+        if(capteur_courant > 11){
+            capteur_courant = 0;
+        }
 
+        // Affichage des distances sur les LEDs.
+        affiche_distance_sur_led(distance_capteur_cm);
+
+        // Envoie des valeurs des capteurs
         for(uint8_t capteur=0; capteur<12; capteur++){
             context.mem[capteur] = distance_capteur_cm[capteur];
         }
+
+        // Reception des données à afficher sur les capteurs
+        // Si nous avons reçu une nouvelle commande
+        if(tampon_commande_led[0] != context.mem[0x10] ||
+                tampon_commande_led[1] != context.mem[0x11] ||
+                tampon_commande_led[2] != context.mem[0x12] ){
+            
+            tampon_commande_led[0] = context.mem[0x10];
+            tampon_commande_led[1] = context.mem[0x11];
+            tampon_commande_led[2] = context.mem[0x12];
+
+            uint8_t couleur = tampon_commande_led[0];
+            uint16_t masque_led = (tampon_commande_led[1] << 8) | tampon_commande_led[2];
+            
+            reset_affichage_led();
+            for(uint8_t led=0; led < 12; led++){
+                if((masque_led >> led) & 0x01){
+                    affiche_couleur_sur_led(couleur, led);
+                }
+            }
+            ws2812_affiche_buffer();
+        }
     }
-
-    
-
 }
 
 

ws2812.c

@@ -110,6 +110,12 @@ void ws2812_set_buffer_rgb(uint8_t rouge, uint8_t vert, uint8_t bleu, uint8_t in
         ws2812_set_buffer(urgb_u32(rouge, vert,bleu), index_led);
 }
 
+//Bit    7  6  5  4  3  2  1  0
+//Data   R  R  R  G  G  G  B  B
+void ws2812_set_buffer_8bits(uint8_t couleur, uint8_t index_led){
+        ws2812_set_buffer(urgb_u32(couleur >> 5, (couleur >> 2) & 0x07, couleur & 0x03), index_led);
+}
+
 /// @brief Rempli le buffer à envoyer au LED, necessite d'appeler la fonction ws2812_affiche_buffer() ensuite
 /// @param couleur : couleur en RVB
 /// @param index_led : index entre 0 et 11

ws2812.h

@@ -3,4 +3,5 @@
 void ws2812_init(void);
 void ws2812_affiche_buffer(void);
 void ws2812_set_buffer_rgb(uint8_t rouge, uint8_t vert, uint8_t bleu, uint8_t index_led);
+void ws2812_set_buffer_8bits(uint8_t couleur, uint8_t index_led);
 void ws2812_arc_en_ciel(void);