ICM42688
1.0.0
Bibliothèque Arduino pour communiquer avec les unités de mesure inertielle (IMU) à six axes ICM42688.
L'InvenSense ICM42688 prend en charge la communication I2C, jusqu'à 400 kHz, et SPI, jusqu'à 1 MHz pour la configuration du registre et 24 MHz pour la lecture des données. Les plages de capteurs pleine échelle sélectionnables suivantes sont disponibles :
| Gamme de gyroscopes à grande échelle | Gamme complète d’accéléromètres |
|---|---|
| +/- 15,6 (degrés/s) | - |
| +/- 31,2 (degrés/s) | - |
| +/- 62,5 (degrés/s) | - |
| +/- 125 (degrés/s) | - |
| +/- 250 (degrés/s) | +/- 2 (g) |
| +/- 500 (degrés/s) | +/- 4 (g) |
| +/- 1000 (degrés/s) | +/- 8 (g) |
| +/- 2000 (degrés/s) | +/- 16 (g) |
L'ICM42688 échantillonne les gyroscopes et les accéléromètres avec des convertisseurs analogique-numérique 16 bits. Il comprend également des filtres numériques programmables, une horloge de précision, un capteur de température intégré, des interruptions programmables (y compris le réveil en cas de mouvement) et un tampon FIFO de 512 octets.
Cette bibliothèque prend en charge la communication I2C et SPI avec l'ICM42688.
Clonez ou téléchargez simplement cette bibliothèque dans votre dossier Arduino/libraries.
Cette bibliothèque prend en charge la communication I2C et SPI avec l'ICM42688. La déclaration d'objet ICM42688 est surchargée de différentes déclarations pour la communication I2C et SPI. Toutes les autres fonctions restent les mêmes. De plus, une classe dérivée, ICM42688FIFO , est incluse, qui fournit des fonctionnalités de configuration FIFO et de collecte de données en plus de toutes les fonctionnalités incluses dans la classe de base ICM42688 .
ICM42688 (TwoWire &bus, adresse uint8_t) Un objet ICM42688 doit être déclaré, spécifiant le bus I2C et l'adresse ICM42688 I2C. L'adresse I2C ICM42688 sera 0x68 si la broche AD0 est mise à la terre ou 0x69 si la broche AD0 est tirée vers le haut. Par exemple, le code suivant déclare un objet ICM42688 appelé IMU avec un capteur ICM42688 situé sur le bus I2C 0 avec une adresse de capteur de 0x68 (AD0 mis à la terre).
ICM42688 IMU (Wire, 0x68 );ICM42688 (TwoWire &bus, adresse uint8_t) Un objet ICM42688 doit être déclaré, spécifiant le bus I2C et l'adresse ICM42688 I2C. L'adresse I2C ICM42688 sera 0x68 si la broche AD0 est mise à la terre ou 0x69 si la broche AD0 est tirée vers le haut. Par exemple, le code suivant déclare un objet ICM42688 appelé IMU avec un capteur ICM42688 situé sur le bus I2C 0 avec une adresse de capteur de 0x68 (AD0 mis à la terre). Vous devez spécifier les broches SDA et SCL pour votre connexion I2C (la valeur par défaut pour Arduino est SDA=18, SCL=19, ESP32 est SDA=21, SCL=22)
ICM42688 IMU (Wire, 0x68 , _sda_pin, _scl_pin);ICM42688FIFO(SPIClass &bus, uint8_t csPin, uint32_t SPI_HS_CLK=8000000) Un objet ICM42688 doit être déclaré, spécifiant le bus SPI et la broche de sélection de puce utilisés. Plusieurs objets ICM42688 ou autres objets SPI peuvent être utilisés sur le même bus SPI, chacun avec sa propre broche de sélection de puce. La broche de sélection de puce peut être n’importe quelle broche numérique disponible. Par exemple, le code suivant déclare un objet ICM42688 appelé IMU avec un capteur ICM42688 situé sur le bus SPI 0 avec la broche de sélection de puce 10.
ICM42688 IMU (SPI, 10 );Notez que l'horloge du bus SPI haute vitesse par défaut est réglée sur 8 MHz, mais l'ICM 42688-p prend en charge une horloge SPI jusqu'à 24 MHz. Utilisez une horloge plus rapide pour des transferts de données SPI plus rapides lors de la lecture des données.
Les fonctions suivantes sont utilisées pour configurer le capteur ICM42688. Ceux-ci doivent être appelés une fois avant la collecte des données, cela se fait généralement dans la fonction Arduino setup() . La fonction begin() doit toujours être utilisée. En option, les fonctions setAccelFS et setGyroFS , setAccelODR et setGyroODR peuvent être utilisées pour définir les plages pleine échelle de l'accéléromètre et du gyroscope et le débit de données de sortie sur des valeurs autres que celles par défaut. Les enableDataReadyInterrupt et disableDataReadyInterrupt contrôlent si l'ICM42688 génère une interruption lorsque les données sont prêtes. Le enableFifo configure et active le tampon FIFO. Ces fonctions sont décrites en détail ci-dessous.
int start() Cela devrait être appelé dans votre fonction de configuration. Il initialise la communication avec l'ICM42688, configure le capteur pour lire les données et estime le biais du gyroscope, qui est supprimé des données du capteur. Cette fonction renvoie une valeur positive en cas d'initialisation réussie et renvoie une valeur négative en cas d'initialisation échouée. En cas d'échec, veuillez vérifier votre câblage ou essayer de réinitialiser l'alimentation du capteur. Ce qui suit est un exemple de configuration de l'ICM42688.
int status = IMU.begin();(facultatif) int setAccelRange(AccelRange range) Cette fonction définit la plage pleine échelle de l'accéléromètre à la valeur donnée. Par défaut, si cette fonction n'est pas appelée, une plage pleine échelle de +/- 16 g sera utilisée. Les plages pleine échelle énumérées de l’accéléromètre sont :
| Nom de l'accéléromètre | Gamme complète d’accéléromètres |
|---|---|
| gpm2 | +/- 2 (g) |
| gpm4 | +/- 4 (g) |
| gpm8 | +/- 8 (g) |
| gpm16 | +/- 16 (g) |
Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec. Veuillez consulter l' exemple Advanced_I2C . Ce qui suit est un exemple de sélection d’une plage pleine échelle d’accéléromètre de +/- 8 g.
status = IMU.setAccelFS(ICM42688::gpm2);(facultatif) int setGyroRange(GyroRange range) Cette fonction définit la plage pleine échelle du gyroscope à la valeur donnée. Par défaut, si cette fonction n'est pas appelée, une plage pleine échelle de +/- 2000 deg/s sera utilisée. Les plages de gyroscope énumérées à grande échelle sont :
| Nom du gyroscope | Gamme de gyroscopes à grande échelle |
|---|---|
| dps15_625 | +/- 15,625 (degrés/s) |
| dps31_25 | +/- 31,25 (degrés/s) |
| dps62_5 | +/- 62,5 (degrés/s) |
| dps125 | +/- 125 (degrés/s) |
| dps250 | +/- 250 (degrés/s) |
| dps500 | +/- 500 (degrés/s) |
| dps1000 | +/- 1000 (degrés/s) |
| dps2000 | +/- 2000 (degrés/s) |
Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec. Veuillez consulter l' exemple Advanced_I2C . Ce qui suit est un exemple de sélection d'une plage pleine échelle de gyroscope de +/- 250 deg/s.
status = IMU.setGyroFS(ICM42688::dps250);(facultatif) int setFilters(bool gyroFilters, bool accFilters) Il s'agit d'une fonction facultative pour définir les filtres programmables (Notch Filter, Anti-Alias Filter, UI Filter Block). Par défaut, tous les filtres sont activés. La figure suivante montre un schéma fonctionnel du chemin du signal pour ICM42688 :
Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec. Ce qui suit est un exemple d’activation des filtres.
status = IMU.setFilters( true , true );(facultatif) int activateDataReadyInterrupt() Une interruption est liée au débit de sortie des données. La broche ICM42688 INT émettra une impulsion de 50 us lorsque les données seront prêtes. Ceci est extrêmement utile pour utiliser des interruptions pour synchroniser la collecte de données qui devrait avoir lieu à intervalle régulier. Veuillez consulter l' exemple Interrupt_SPI . Cette fonction active cette interruption, qui se produira à une fréquence donnée par le SRD. Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec. Ce qui suit est un exemple d’activation de l’interruption de données prêtes.
status = IMU.enableDataReadyInterrupt();(facultatif) int DisableDataReadyInterrupt() Cette fonction désactive l'interruption de données prêtes, décrite ci-dessus. Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec. Ce qui suit est un exemple de désactivation de l'interruption de données prêtes.
status = IMU.disableDataReadyInterrupt();(facultatif) uin8_t isInterrupted() Cette fonction lit le registre d'interruption des données prêtes. Cette fonction renvoie vrai lorsqu'elle est interrompue. Ce qui suit est un exemple de lecture du registre d'interruption de données prêtes.
status = IMU.isInterrupted();(facultatif) int calibrateGyro() Le biais du gyroscope est automatiquement estimé pendant la fonction start() et supprimé des mesures du capteur. Cette fonction réestimera le biais du gyroscope et supprimera le nouveau biais des futures mesures du capteur. Le capteur doit être immobile pendant ce processus. Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec. Ce qui suit est un exemple d’estimation de nouveaux biais gyroscopiques.
status = IMU.calibrateGyro();(facultatif) float getGyroBiasX() Cette fonction renvoie le biais actuel du gyroscope dans la direction X en unités de degrés/s.
float gxb;
gxb = IMU.getGyroBiasX();(facultatif) float getGyroBiasY() Cette fonction renvoie le biais actuel du gyroscope dans la direction Y en unités de degrés/s.
float gyb;
gyb = IMU.getGyroBiasY();(facultatif) float getGyroBiasZ() Cette fonction renvoie le biais actuel du gyroscope dans la direction Z en unités de degrés/s.
float gzb;
gzb = IMU.getGyroBiasZ();(facultatif) void setGyroBiasX(float Bias) Cette fonction définit le biais du gyroscope utilisé dans la direction X sur la valeur d'entrée en unités de degrés/s.
float gxb = 0.001 ; // gyro bias of 0.001 deg/s
IMU.setGyroBiasX(gxb);(facultatif) void setGyroBiasY(float biais) Cette fonction définit le biais du gyroscope utilisé dans la direction Y sur la valeur d'entrée en unités de degrés/s.
float gyb = 0.001 ; // gyro bias of 0.001 deg/s
IMU.setGyroBiasY(gyb);(facultatif) void setGyroBiasZ(float Bias) Cette fonction définit le biais du gyroscope utilisé dans la direction Z sur la valeur d'entrée en unités de degrés/s.
float gzb = 0.001 ; // gyro bias of 0.001 deg/s
IMU.setGyroBiasZ(gzb);(facultatif) int calibrateAccel() Cette fonction estimera le biais et le facteur d'échelle nécessaires pour calibrer les accéléromètres. Cette fonction fonctionne sur un axe à la fois et doit être exécutée pour les 6 orientations du capteur. Après avoir collecté suffisamment de données de capteur, il estimera le biais et le facteur d'échelle pour les trois canaux de l'accéléromètre et appliquera ces corrections aux données mesurées. L'étalonnage de l'accéléromètre ne doit être effectué qu'une seule fois sur l'IMU, les fonctions d'obtention et de réglage détaillées ci-dessous peuvent être utilisées pour récupérer le biais et les facteurs d'échelle estimés et les utiliser lors de futurs cycles d'alimentation ou opérations avec l'IMU. Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec.
status = IMU.calibrateAccel();(facultatif) float getAccelBiasX_mss() Cette fonction renvoie le biais actuel de l'accéléromètre dans la direction X en unités de m/s/s.
float axb;
axb = IMU.getAccelBiasX_mss();(facultatif) float getAccelScaleFactorX() Cette fonction renvoie le facteur d'échelle actuel de l'accéléromètre dans la direction X.
float axs;
axs = IMU.getAccelScaleFactorX();(facultatif) float getAccelBiasY_mss() Cette fonction renvoie le biais actuel de l'accéléromètre dans la direction Y en unités de m/s/s.
float ayb;
ayb = IMU.getAccelBiasY_mss();(facultatif) float getAccelScaleFactorY() Cette fonction renvoie le facteur d'échelle actuel de l'accéléromètre dans la direction Y.
float ays;
ays = IMU.getAccelScaleFactorY();(facultatif) float getAccelBiasZ_mss() Cette fonction renvoie le biais actuel de l'accéléromètre dans la direction Z en unités de m/s/s.
float azb;
azb = IMU.getAccelBiasZ_mss();(facultatif) float getAccelScaleFactorZ() Cette fonction renvoie le facteur d'échelle actuel de l'accéléromètre dans la direction Z.
float azs;
azs = IMU.getAccelScaleFactorZ();(facultatif) void setAccelCalX(float biais,float scaleFactor) Cette fonction définit le biais de l'accéléromètre (m/s/s) et le facteur d'échelle utilisé dans la direction X sur les valeurs d'entrée.
float axb = 0.01 ; // accel bias of 0.01 m/s/s
float axs = 0.97 ; // accel scale factor of 0.97
IMU.setAccelCalX(axb,axs);(facultatif) void setAccelCalY(float biais,float scaleFactor) Cette fonction définit le biais de l'accéléromètre (m/s/s) et le facteur d'échelle utilisé dans la direction Y sur les valeurs d'entrée.
float ayb = 0.01 ; // accel bias of 0.01 m/s/s
float ays = 0.97 ; // accel scale factor of 0.97
IMU.setAccelCalY(ayb,ays);(facultatif) void setAccelCalZ(float biais,float scaleFactor) Cette fonction définit le biais de l'accéléromètre (m/s/s) et le facteur d'échelle utilisé dans la direction Z sur les valeurs d'entrée.
float azb = 0.01 ; // accel bias of 0.01 m/s/s
float azs = 0.97 ; // accel scale factor of 0.97
IMU.setAccelCalZ(azb,azs);Les fonctions ci-dessous sont utilisées pour collecter les données du capteur ICM42688. Veuillez vous référer à la fiche technique Section 10.1 pour l'orientation des axes sensibles.
int getAGT() lit le capteur et stocke les données les plus récentes dans un tampon, il doit être appelé chaque fois que vous souhaitez récupérer des données du capteur. Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec.
IMU.getAGT();float accX() obtient la valeur de l'accéléromètre du tampon de données dans la direction X et la renvoie en unités de g.
float ax = IMU.accX();float accY() obtient la valeur de l'accéléromètre du tampon de données dans la direction Y et la renvoie en unités de g.
float ay = IMU.accY();float accZ() obtient la valeur de l'accéléromètre du tampon de données dans la direction Z et la renvoie en unités de g.
float az = IMU.accZ();float gyrX() obtient la valeur du gyroscope du tampon de données dans la direction X et la renvoie en unités de degrés/s.
float gx = IMU.gyrX();float gyrY() obtient la valeur du gyroscope du tampon de données dans la direction Y et la renvoie en unités de degrés/s.
float gy = IMU.gyrY();float gyrZ() obtient la valeur du gyroscope du tampon de données dans la direction Z et la renvoie en unités de degrés/s.
float gz = IMU.gyrZ();float temp() obtient la valeur de température de la matrice à partir du tampon de données et la renvoie en unités de C.
float temperature = IMU.temp();La classe dérivée ICM42688FIFO étend les fonctionnalités fournies par la classe de base ICM42688 en prenant en charge la configuration et la lecture du tampon ICM42688FIFO. Toutes les fonctions décrites ci-dessus, dans le cadre de la classe ICM42688, sont également disponibles pour la classe ICM42688FIFO .
ICM42688FIFO (TwoWire &bus, adresse uint8_t) Un objet ICM42688FIFO doit être déclaré, spécifiant le bus I2C et l'adresse ICM42688 I2C. L'adresse I2C ICM42688 sera 0x68 si la broche AD0 est mise à la terre ou 0x69 si la broche AD0 est tirée vers le haut. Par exemple, le code suivant déclare un objet ICM42688FIFO appelé IMU avec un capteur ICM42688 situé sur le bus I2C 0 avec une adresse de capteur de 0x68 (AD0 mis à la terre).
ICM42688FIFO IMU (Wire, 0x68 );ICM42688FIFO(SPIClass &bus, uint8_t csPin, uint32_t SPI_HS_CLK=8000000) Un objet ICM42688FIFO doit être déclaré, spécifiant le bus SPI et la broche de sélection de puce utilisés. Plusieurs objets ICM42688 ou autres objets SPI peuvent être utilisés sur le même bus SPI, chacun avec sa propre broche de sélection de puce. La broche de sélection de puce peut être n’importe quelle broche numérique disponible. Par exemple, le code suivant déclare un objet ICM42688FIFO appelé IMU avec un capteur ICM42688 situé sur le bus SPI 0 avec la broche de sélection de puce 10.
ICM42688FIFO IMU (SPI, 10 );Notez que l'horloge du bus SPI haute vitesse par défaut est réglée sur 8 MHz, mais l'ICM 42688-p prend en charge une horloge SPI jusqu'à 24 MHz. Utilisez une horloge plus rapide pour des transferts de données SPI plus rapides lors de la lecture des données.
(facultatif) int activateFifo(bool accel,bool gyro,bool temp) Cette fonction configure et active le tampon FIFO ICM42688. Ce tampon de 512 octets échantillonne les données au débit de sortie de données défini par le SRD et permet au microcontrôleur de lire les données en masse, réduisant ainsi la charge de travail du microcontrôleur pour certaines applications. Il est configuré avec un ensemble de valeurs booléennes décrivant les données à mettre en mémoire tampon dans le FIFO : accéléromètre, gyroscope ou température. Les données de l'accéléromètre et du gyroscope occupent chacune 6 octets d'espace par échantillon et la température 2 octets. Il est important de sélectionner uniquement les sources de données souhaitées pour s'assurer que le FIFO ne dépasse pas entre ses lectures. Par exemple, l'activation de toutes les sources de données nécessiterait 21 octets par échantillon, ce qui permettrait au FIFO de ne contenir que 24 échantillons avant de déborder. Si seules les données de l'accéléromètre sont nécessaires, cela passe à 85 échantillons avant de déborder. Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec. Veuillez consulter l' exemple FIFO_SPI . Ce qui suit est un exemple d'activation du FIFO pour mettre en mémoire tampon les données de l'accéléromètre et du gyroscope.
status = IMU.enableFifo( true , true , false , false );int readFifo() lit le tampon FIFO de l'ICM42688, l'analyse et stocke les données dans des tampons sur le microcontrôleur. Il doit être appelé chaque fois que vous souhaitez récupérer des données du tampon FIFO. Cette fonction renvoie une valeur positive en cas de succès et une valeur négative en cas d'échec.
IMU.readFifo();void getFifoAccelX_mss(size_t size,float data) obtient la valeur de l'accéléromètre du tampon de données dans la direction X et la renvoie en unités de m/s/s. Les données sont renvoyées sous forme de tableau avec le nombre d'éléments dans ce tableau. Assurez-vous que le tampon vers lequel vous effectuez le transfert dispose de suffisamment de capacité pour stocker les données.
float ax[ 100 ];
size_t samples;
IMU.getFifoAccelX_mss(&samples,ax);void getFifoAccelY_mss(size_t size,float data) obtient la valeur de l'accéléromètre du tampon de données dans la direction Y et la renvoie en unités de m/s/s. Les données sont renvoyées sous forme de tableau avec le nombre d'éléments dans ce tableau. Assurez-vous que le tampon vers lequel vous effectuez le transfert dispose de suffisamment de capacité pour stocker les données.
float ay[ 100 ];
size_t samples;
IMU.getFifoAccelY_mss(&samples,ay);void getFifoAccelZ_mss(size_t size,float data) obtient la valeur de l'accéléromètre du tampon de données dans la direction Z et la renvoie en unités de m/s/s. Les données sont renvoyées sous forme de tableau avec le nombre d'éléments dans ce tableau. Assurez-vous que le tampon vers lequel vous effectuez le transfert dispose de suffisamment de capacité pour stocker les données.
float az[ 100 ];
size_t samples;
IMU.getFifoAccelZ_mss(&samples,az);void getFifoGyroX(size_t size,float data) obtient la valeur du gyroscope du tampon de données dans la direction X et la renvoie en unités de degrés/s. Les données sont renvoyées sous forme de tableau avec le nombre d'éléments dans ce tableau. Assurez-vous que le tampon vers lequel vous effectuez le transfert dispose de suffisamment de capacité pour stocker les données.
float gx[ 100 ];
size_t samples;
IMU.getFifoGyroX(&samples,gx);void getFifoGyroY(size_t size,float data) obtient la valeur du gyroscope du tampon de données dans la direction Y et la renvoie en unités de degrés/s. Les données sont renvoyées sous forme de tableau avec le nombre d'éléments dans ce tableau. Assurez-vous que le tampon vers lequel vous effectuez le transfert dispose de suffisamment de capacité pour stocker les données.
float gy[ 100 ];
size_t samples;
IMU.getFifoGyroY(&samples,gy);void getFifoGyroZ(size_t size,float data) obtient la valeur du gyroscope du tampon de données dans la direction Z et la renvoie en unités de degrés/s. Les données sont renvoyées sous forme de tableau avec le nombre d'éléments dans ce tableau. Assurez-vous que le tampon vers lequel vous effectuez le transfert dispose de suffisamment de capacité pour stocker les données.
float gz[ 100 ];
size_t samples;
IMU.getFifoGyroZ(&samples,gx);void getFifoTemperature_C(size_t size,float data) obtient la valeur de température de la matrice du tampon de données et la renvoie en unités de C. Les données sont renvoyées sous forme de tableau avec le nombre d'éléments dans ce tableau. Assurez-vous que le tampon vers lequel vous effectuez le transfert dispose de suffisamment de capacité pour stocker les données.
float temp[ 100 ];
size_t samples;
IMU.getFifoTemperature_C(&samples,temp);Veuillez vous référer à la fiche technique ICM42688. Cette bibliothèque devrait bien fonctionner pour d'autres cartes de dérivation ou capteurs intégrés, veuillez vous référer au schéma de brochage de votre fournisseur.
Les broches ICM42688 doivent être connectées comme :
Des résistances de 4,7 kOhm doivent être utilisées comme pullups sur SDA et SCL, ces résistances doivent être utilisées avec une source de 3,3 V.
Les broches ICM42688 doivent être connectées comme :
Certaines cartes de dérivation, notamment la carte de dérivation Embedded Masters, nécessitent de légères modifications pour activer SPI. Veuillez vous référer à la documentation de votre fournisseur.
