Commencer avec l'interface de capteur I2C ?? - Interfacez votre MMA8451 à l'aide d'ESP32 : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Dans ce tutoriel, vous apprendrez tout sur Comment démarrer, connecter et faire fonctionner un périphérique I2C (accéléromètre) avec un contrôleur (Arduino, ESP32, ESP8266, ESP12 NodeMCU)

Étape 1: Comment démarrer avec I2C - Magnificent World of Inter IC Communication

Les Arduino, ESP Series, PIC, Rasberry PI, etc. sont tous incroyables. Mais qu'en faites-vous une fois que vous en avez un ?

La meilleure chose est d'ajouter des capteurs et autres. Aujourd'hui, une grande partie des nouvelles technologies utilisent le protocole I2C pour permettre à l'ordinateur, aux téléphones, aux tablettes ou aux microcontrôleurs de communiquer avec les capteurs. Les téléphones intelligents seraient moins intelligents s'ils ne pouvaient pas parler à ce capteur d'accéléromètre pour savoir dans quelle direction votre téléphone est orienté.

Étape 2: Présentation sur I2C

I2C est un protocole de communication série, synchrone, semi-duplex qui permet la coexistence de plusieurs maîtres et esclaves sur le même bus. Le bus I2C se compose de deux lignes: la ligne de données série (SDA) et l'horloge série (SCL). Les deux lignes nécessitent des résistances de rappel.

SDA (Serial Data) – La ligne permettant au maître et à l'esclave d'envoyer et de recevoir des données. SCL (Serial Clock) – La ligne qui transporte le signal d'horloge. Avec des avantages tels que la simplicité et le faible coût de fabrication, I2C est principalement utilisé pour la communication de périphériques à faible vitesse sur de courtes distances (moins d'un pied).

Vous voulez en savoir plus sur I2C ?……

Étape 3: Comment configurer les capteurs I²C

Avant de vous lancer dans le projet, vous devez comprendre quelques bases de votre capteur. Alors servez-vous une tasse de café avant de plonger:) ? …

La grande force d'I2C est que vous pouvez mettre autant de capteurs sur les mêmes quatre fils. Mais pour les unités avec plusieurs modules préfabriqués connectés, vous devrez peut-être retirer quelques résistances smd des évasions, sinon le pull-up sur le bus pourrait devenir trop agressif.

Quelles informations voulons-nous de la fiche technique ??

1. Fonctionnalité du capteur
2. Fonctionnalité des brochages et des broches
3. Description de l'interface (Ne manquez pas de regarder sur « Tableau de sélection des adresses I2c »)
4. Inscriptions !!

Tout va bien vous le trouverez facilement mais Registres ?? Les REGISTRES sont simplement des emplacements de mémoire à l'intérieur d'un appareil I²C. Le résumé du nombre de registres dans un capteur donné et de ce qu'ils contrôlent ou contiennent est appelé une carte de registre. La plupart des informations sur la fiche technique du capteur expliquent le fonctionnement de chaque registre, et elles peuvent être assez fastidieuses à lire car les informations sont rarement présentées de manière directe.

Pour vous donner une idée de ce que je veux dire par là: Il existe de nombreux types de registres, mais pour cette introduction, je vais les regrouper en deux types généraux: les registres de contrôle et de données.

1) Registres de contrôle

La plupart des capteurs modifient leur fonctionnement en fonction des valeurs stockées dans les registres de contrôle. Considérez les registres de contrôle comme des banques de commutateurs On/Off, que vous activez en réglant un bit sur 1 et désactivez en réglant ce bit sur 0. Les capteurs à puce I²C ont souvent une douzaine ou plus de paramètres opérationnels pour des choses comme bit- Modes, interruptions, contrôle de lecture-écriture, profondeur, vitesse d'échantillonnage, réduction du bruit, etc., vous devez donc généralement définir des bits dans plusieurs registres de contrôle différents avant de pouvoir réellement effectuer une lecture.

2) Registres de donnéesContrairement à une banque de commutateurs de registres de contrôle, je considère les registres de sortie de données comme des conteneurs contenant des nombres qui se trouvent être stockés sous forme binaire. Donc, vous voulez connaître les données, toujours lire les registres de données comme qui suis-je inscrit pour l'identification de l'appareil, le registre d'état, etc.

Ainsi, l'initialisation d'un capteur I²C est un processus en plusieurs étapes et l'ordre correct des opérations est souvent expliqué par écrit dans le sens inverse, au lieu d'être simple dans la fiche technique. liste ne disant jamais "Pour obtenir une lecture de ce capteur, faites (1), (2), (3), (4), etc", mais vous trouvez des descriptions des bits du registre de contrôle disant "avant de définir le bit x dans ce registre, vous devez définir le bit y dans cet autre registre de contrôle ».

Pourtant, je trouve toujours qu'une fiche technique est plus interactive que la plupart des textes. si vous le référencerez pour un ou plusieurs éléments d'information spécifiques et qu'il vous donnera tous les détails, connexions et références. Asseyez-vous et lisez pour sortir toutes vos références.:)

Étape 4: Démarrer avec le mouvement - Accéléromètre

Les accéléromètres modernes sont des dispositifs de microsystèmes électromécaniques (MEMS), ce qui signifie qu'ils peuvent s'adapter sur une petite puce à l'intérieur du plus petit des gadgets. Une méthode pour mesurer l'accélération employée par les accéléromètres MEMS consiste à utiliser une minuscule masse conductrice suspendue à des ressorts. L'accélération de l'appareil provoque l'étirement ou la contraction des ressorts, et la déviation de la masse conductrice peut être mesurée par un changement de capacité des plaques fixes voisines.

Les accéléromètres sont spécifiés par les caractéristiques suivantes:

1. Le nombre d'axes, d'un à trois axes, étiquetés X, Y et Z dans les diagrammes de spécifications. Notez que certains accéléromètres sont appelés 6 axes ou 9 axes, mais cela signifie simplement qu'ils sont regroupés avec d'autres dispositifs MEMS tels que des gyroscopes et/ou des magnétomètres. Chacun de ces appareils a également trois axes, c'est pourquoi il existe des unités de mesure inertielle (IMU) à 3, 6 ou 9 axes.
2. Le type de sortie, analogique ou numérique. Un accéléromètre numérique prend en charge le formatage des données d'accélération en une représentation numérique pouvant être lue via I2C ou SPI.
3. La plage d'accélération mesurée en g, où 1g est l'accélération due à la gravité terrestre.
4. Coprocesseurs qui peuvent décharger certains des calculs nécessaires pour analyser les données brutes du MCU. La plupart des accéléromètres ont une capacité d'interruption simple pour détecter un seuil d'accélération (choc) et une condition 0-g (chute libre). D'autres peuvent effectuer un traitement avancé sur les données brutes pour offrir des données plus significatives au MCU.

Étape 5: Interface avec le contrôleur

Puisque nous connaissons les microcontrôleurs ESP en tendance, nous utiliserons ESP32 pour notre exemple. Donc, vous avez d'abord besoin d'un Nodemcu-32s.

Pas de soucis si vous avez d'autres cartes ESP ou même Arduino !!! Il vous suffit de configurer votre IDE Arduino et la configuration selon vos cartes de développement, pour Arduino, ESP NodeMCU, ESP32s, etc. Vous aurez également besoin de pièces I2C, généralement sur une carte de dérivation. Dans ce tutoriel, je vais utiliser MMA8451 carte de dérivation accéléromètre numérique.

Et quelques fils volants….

Étape 6: Connexions

Et voici une mise en page.

J'ai utilisé la connexion suivante du module ci-dessus à mon module Nodemcu-32s.

ESP32s -- Module

3v3 -- Vin

Gnd -- Gnd

SDA 21 -- SDA

SCL 22 -- SCL

"N'oubliez pas que la plupart du temps, toutes les cartes de développement (principalement dans les ESP) n'ont pas un bon brochage clair pour aider à déterminer quelles broches sont utilisées !! Donc, avant la connexion, identifiez les bonnes broches de votre carte à utiliser pour SDA et SCL."

Étape 7: Coder

Cela nécessite la bibliothèque Adafruit

de

Téléchargez, décompressez et vous trouverez le dossier des exemples, dans le dossier, ouvrez simplement la démo MMA8451 dans votre IDE Arduino et c'est parti….

vous verrez le code suivant pour votre interface de capteur MMA8451 avec votre contrôleur

#comprendre

#include #include Adafruit_MMA8451 mma = Adafruit_MMA8451(); void setup(void) { Serial.begin(9600); Fil.begin(4, 5); /* rejoindre le bus i2c avec SDA=D1 et SCL=D2 de NodeMCU */ Serial.println("Adafruit MMA8451 test!"); if (! mma.begin()) { Serial.println("Impossible de démarrer"); tandis que (1); } Serial.println("MMA8451 trouvé!"); mma.setRange(MMA8451_RANGE_2_G); Serial.print("Plage = "); Serial.print(2 << mma.getRange()); Serial.println("G"); } void loop() { // Lit les données 'brutes' en nombre de 14 bits mma.read(); Serial.print("X:\t"); Serial.print(mma.x); Serial.print("\tY:\t"); Serial.print(mma.y); Serial.print("\tZ:\t"); Serial.print(mma.z); Serial.println(); /* Récupère un nouvel événement de capteur */ sensor_event_t event; mma.getEvent(&event); /* Affiche les résultats (l'accélération est mesurée en m/s^2) */ Serial.print("X: \t"); Serial.print(event.acceleration.x); Serial.print("\t"); Serial.print("Y: \t"); Serial.print(event.acceleration.y); Serial.print("\t"); Serial.print("Z: \t"); Serial.print(event.acceleration.z); Serial.print("\t"); Serial.println("m/s^2 "); /* Récupère l'orientation du capteur */ uint8_t o = mma.getOrientation(); switch (o) { case MMA8451_PL_PUF: Serial.println("Portrait Up Front"); Pause; case MMA8451_PL_PUB: Serial.println("Portrait Up Back"); Pause; cas MMA8451_PL_PDF: Serial.println("Portrait Down Front"); Pause; case MMA8451_PL_PDB: Serial.println("Portrait vers le bas"); Pause; cas MMA8451_PL_LRF: Serial.println("Paysage avant droit"); Pause; case MMA8451_PL_LRB: Serial.println("Paysage arrière droit"); Pause; case MMA8451_PL_LLF: Serial.println("Paysage avant gauche"); Pause; case MMA8451_PL_LLB: Serial.println("Paysage arrière gauche"); Pause; } Serial.println(); retard(1000); }

Enregistrer, vérifier et télécharger……

Ouvrez le moniteur série et vous verrez quelque chose comme ça, je déplaçais le capteur d'où les différentes lectures

X: -2166 Y: 1872 Z: 2186

X: -2166 Y: 1872 Z: 2186X: -4,92 Y: 5,99 Z: 4,87 m/s^2

Paysage avant gauche

X: -224 Y: -2020 Z: 3188

X: -5,10 Y: -3,19 Z: 7,00 m/s^2

Portrait à l'avant

Eh bien, si tout s'est passé comme il se doit, alors vous avez maintenant les bases d'I2C et comment connecter votre appareil.

Mais l'appareil ne fonctionne pas ??

Passez simplement à l'étape suivante……

Étape 8: faites fonctionner votre appareil I2C

Étapes de base pour faire fonctionner l'appareil I2C

Enquêtons….

• Le câblage est correct.. (vérifiez-le à nouveau)
• Le programme est correct..(Oui, c'est un exemple de test..)

Commencez par des étapes à résoudre…..

Étape 1: Exécutez le programme de scanner de périphérique I2C pour vérifier l'adresse de l'appareil et d'abord votre périphérique I2C est OK

Vous pouvez télécharger le croquis et vérifier la sortie.

Résultat - L'appareil fonctionne et l'adresse du capteur est correcte

Scanner I2C. Numérisation…

Adresse trouvée: 28 (0x1C) Terminé. 1 appareil(s) trouvé(s).

Étape 2: Vérifier la bibliothèque de capteurs

Ouvrez le fichier Adafruit_MMA8451.h et recherchez l'adresse de l'appareil

Résultat - L'adresse est différente de mon appareil ??

/*================================================ ========================= ADRESSE I2C/BITS --------------------- -------------------------------------------------- */ #define MMA8451_DEFAULT_ADDRESS (0x1D) //!< Adresse I2C MMA8451 par défaut, si A est GND, son 0x1C /*======================== ================================================== */

Faire - Modifier le fichier à partir du bloc-notes (changer d'adresse) + Enregistrer + Redémarrer l'IDE

Cela fonctionne. Vous pouvez obtenir vos lectures.

N'allez pas…..???

Étape 3: Vérifiez que Wire.begin est écrasé ?

Ouvrez le fichier Adafruit_MMA8451.c et recherchez Wire.begin.

Résultat - Cette déclaration est écrasée

/****************************************************** *************************//* ! @brief Configure le matériel (lit les valeurs des coefficients, etc.) */ /************************************ **************************************/ bool Adafruit_MMA8451::begin(uint8_t i2caddr) { Fil.begin(); _i2caddr = i2caddr;

Faire - Modifier le fichier à partir du bloc-notes (instruction de commentaire) + Enregistrer + Redémarrer l'IDE

Et enfin, l'appareil fonctionne…

J'ai presque surchargé ce tutoriel car son objectif principal était d'expliquer comment démarrer, obtenir les données de la fiche technique, connecter et faire fonctionner le périphérique I2C avec un exemple très basique. J'espère que tout se passera comme il se doit, et cela sera utile pour démarrer votre capteur.