Gyroscope amusant avec anneau néopixel : 4 étapes (avec photos)

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

Dans ce tutoriel, nous allons utiliser le gyroscope MPU6050, un anneau néopixel et un arduino pour construire un appareil qui allume des led correspondant à l'angle d'inclinaison.

C'est un projet simple et amusant et il va être assemblé sur une maquette. Si vous suivez les étapes, vous construirez ce que vous avez vu dans la vidéo. C'est un bon tutoriel pour apprendre le gyroscope et l'anneau néopixel.

Je construis ce tutoriel en raison de l'intérêt que j'ai vu sur mon premier instructable ici (Gyroscope Led Control With Arduino). Dans ce instructable, j'ai remplacé les led simples par un anneau de néopixel. L'anneau est plus simple à utiliser grâce à une bibliothèque Adafruit et c'est certainement plus spectaculaire.

Donc, si vous avez ces composants qui traînent, c'est un excellent moyen de les utiliser, je vais essayer de vous guider pas à pas dans la construction de l'appareil et d'expliquer également comment cela fonctionne dans la dernière étape.

Étape 1: Choses requises

les pièces

1. Arduino pro mini 328p (eBay) 2 $

2. Planche à pain

3. Gyroscope MPU6050 (eBay) 1.2$

4. Anneau led 24 néopixels (Adafruit) 17 $

5. 4 piles AA avec 4 piles

6. Câbles de démarrage en forme de U (facultatif). J'ai utilisé ces câbles de démarrage parce qu'ils ont une meilleure apparence sur la planche à pain et que les voyants sont plus visibles de cette façon. Vous pouvez trouver une boîte de 140 sur ebay à environ 4$. Si vous n'avez pas ces câbles, vous pouvez les remplacer par des fils dupont.

Outils:

1. Adaptateur USB vers série FTDI FT232RL pour programmer l'arduino pro mini

2. IDE Arduino

Compétences: 1. Souder, consultez ce tutoriel

3. Programmation arduino de base, ce tutoriel peut être utile

Étape 2: Assemblage

J'ai joint le schéma fritzing au format fzz et une photo de celui-ci pour une visualisation facile des connexions

1. Vous devez souder 3 broches mâles à l'arrière de la bague néopixel comme indiqué sur l'image

- souder la broche positive

- souder le sol

- souder la broche d'entrée de données

2. Ensuite, le support de batterie 4x devrait avoir un moyen de se connecter à la planche à pain, une solution simple consiste à souder deux fils dupont mâles à ses bornes.

3. Préparez la planche à pain.

- placez la bague néopixel, le microcontrôleur et le gyroscope sur la maquette comme sur l'image

- placer tous les fils négatifs: vers le microcontrôleur, bague néopixel, gyroscope

- placer tous les fils positifs: au microcontrôleur, bague néopixel, gyroscope

- placez tous les fils de données:

* SDA et SCL du au microcontrôleur au gyroscope

* broche D6 du microcontrôleur à la bague néopixel

- revérifier toutes les connexions avant de mettre sous tension

- en utilisant éventuellement du ruban adhésif en toile, scotchez la batterie à l'arrière du bradboard pour le maintenir en place et le rendre plus portable

Étape 3: Le code et l'étalonnage

Vous devez d'abord télécharger et installer deux bibliothèques:

1. Adafruit neopixel library sapin contrôlant le neopixel

2. Bibliothèque MPU6050 pour le gyroscope

3. Source de la bibliothèque I2CDev

Ce sont deux excellentes bibliothèques qui feront le gros du travail !

Plus de détails sur les néopixels ici

Ensuite, téléchargez et installez ma bibliothèque à partir d'ici ou copiez-la ci-dessous:

#include "I2Cdev.h"

#include #include "MPU6050_6Axis_MotionApps20.h" #include "Wire.h" #define NEOPIXED_CONTROL_PIN 6 #define NUM_LEDS 24 const int MAX_ANGLE = 45; const int LED_OFFSET = 12; MPU6050 mpu; Bande Adafruit_NeoPixel = Adafruit_NeoPixel(NUM_LEDS, NEOPIXED_CONTROL_PIN, NEO_RBG + NEO_KHZ800); non signé long lastPrintTime = 0; bool initialisation = false; // défini sur true si l'initialisation DMP a réussi uint8_t mpuIntStatus; // contient l'octet d'état d'interruption réel du MPU uint8_t devStatus; // renvoie l'état après chaque opération de périphérique (0 = succès, !0 = erreur) uint16_t packetSize; // taille de paquet DMP attendue (la valeur par défaut est de 42 octets) uint16_t fifoCount; // compte de tous les octets actuellement dans FIFO uint8_t fifoBuffer[64]; // Tampon de stockage FIFO Quaternion q; // [w, x, y, z] conteneur de quaternions VectorFloat Gravity; // [x, y, z] vecteur de gravité float ypr[3]; // [lacet, tangage, roulis] lacet/tangage/roulis conteneur et vecteur de gravité volatile bool mpuInterrupt = false; // indique si la broche d'interruption MPU est passée au niveau haut

void setup()

{ Serial.begin(9600); Serial.println("Programme démarré"); initialisation = initializeGyroscope(); strip.begin(); } void loop() { if (!initialisation) { return; } mpuInterrupt = false; mpuIntStatus = mpu.getIntStatus(); fifoCount = mpu.getFIFOCount(); if (hasFifoOvervoln(mpuIntStatus, fifoCount)) { mpu.resetFIFO(); revenir; } if (mpuIntStatus & 0x02) { while (fifoCount < packetSize) { fifoCount = mpu.getFIFOCount(); } mpu.getFIFOBytes(fifoBuffer, packetSize); fifoCount -= packetSize; mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); redessinerLeds(ypr[0] * 180/M_PI, ypr[1] * 180/M_PI, ypr[2] * 180/M_PI); } } booléen hasFifoOverflown(int mpuIntStatus, int fifoCount) { return mpuIntStatus & 0x10 || Comptefifo == 1024; } void redrawLeds(int x, int y, int z) { x = contrainte(x, -1 * MAX_ANGLE, MAX_ANGLE); y = contrainte(y, -1 * MAX_ANGLE, MAX_ANGLE); if (y 0) { lightLeds(y, z, 0, 5, 0, 89); } else if (y < 0 et z 0 et z 0 et z > 0) { lightLeds(y, z, 20, 24, 89, 0); } } void lightLeds(int x, int y, int fromLedPosition, int toLedPosition, int fromAngle, int toAngle) { double angle = (atan((double) abs(x) / (double) abs (y)) * 4068) / 71; int ledNr = map(angle, fromAngle, toAngle, fromLedPosition, toLedPosition); printDebug(x, y, ledNr, angle); uint32_t couleur; for (int i=0; i position + LED_OFFSET) { retour position + LED_OFFSET; } position de retour + LED_OFFSET - NUM_LEDS; } void printDebug(int y, int z, int lightLed, int angle) { if (millis() - lastPrintTime < 500) { return; } Serial.print("a=");Serial.print(angle);Serial.print("; "); Serial.print("ll=");Serial.print(lightLed);Serial.print("; "); Serial.print("y=");Serial.print(y);Serial.print("; "); Serial.print("z=");Serial.print(z);Serial.println("; "); lastPrintTime = millis(); } bool initializeGyroscope() { Wire.begin(); TWBR = 24; mpu.initialize(); Serial.println(mpu.testConnection() ? F("Connexion MPU6050 réussie"): F("Connexion MPU6050 échouée")); Serial.println(F("Initialisation DMP…")); devStatus = mpu.dmpInitialize(); mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZAccelOffset(1788); if (devStatus != 0) { Serial.print(F("DMP Initialization failed (code "));Serial.println(devStatus); return false; } mpu.setDMPEnabled(true); Serial.println(F("Enabling détection d'interruption (interruption externe Arduino 0)…")); attachInterrupt(0, dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus(); Serial.println(F("DMP prêt! En attente de la première interruption…")); packetSize = mpu.dmpGetFIFOPacketSize(); renvoie vrai; } annuler dmpDataReady() { mpuInterrupt = vrai; }

Téléchargez le code:

À l'aide de l'adaptateur FTDI, téléchargez le code sur l'arduino.

Branchez l'alimentation (piles)

Étalonnage:

La chose la plus importante à calibrer ici est la constante "LED_OFFSET". Dans mon exemple, c'est 12. Vous devez régler cela de 0 à 23 pour qu'après avoir alimenté la carte, la LED s'allume dans la direction dans laquelle vous inclinez la carte.

Si vous voulez en savoir plus sur son fonctionnement, consultez la dernière étape

Étape 4: Comment ça marche (facultatif)

Tout d'abord quelques informations sur le gyroscope MPU6050. Il s'agit d'un gyroscope MEMS (MEMS signifie Microelectromechanical systems).

Chaque type de gyroscope MEMs a une certaine forme de composant oscillant à partir duquel l'accélération, et donc le changement de direction, peut être détecté. En effet, conformément à la loi de conservation du mouvement, un objet vibrant aime continuer à vibrer dans le même plan, et toute déviation vibrationnelle peut être utilisée pour dériver un changement de direction.

Le gyroscope contient également son propre microcontrôleur pour calculer le roulis, le tangage et le lacet grâce à des calculs mathématiques sophistiqués.

Mais les données brutes du gyroscope souffrent de bruit et de dérive, nous avons donc utilisé une bibliothèque externe pour lisser les choses et nous fournir des données utilisables propres.

Les Neopixel sont des leds RVB adressables individuellement et enchaînées en bandes et anneaux. Ils fonctionnent sur 5V et contiennent leurs propres circuits, vous n'avez donc qu'à alimenter les néopixels et à communiquer avec eux en utilisant la ligne de données. La communication se fait avec une seule ligne de données contenant l'horloge et les données (plus de détails ici). Adafruit fournit une bibliothèque propre pour interagir avec les anneaux néopixels.

Le code

Dans la fonction loop(), la bibliothèque MPU6050_6Axis_MotionApps20 est appelée. Lorsque la bibliothèque a de nouvelles données du gyroscpe, elle appelle redrawLeds (x, y, z) avec 3 arguments représentant le lacet, le tangage et le roulis

À l'intérieur des leds redessinées ():

- on se concentre sur deux axes: y, z

- nous contraignons les deux axes de -MAX_ANGLE à +MAX_ANGLE, nous avons défini l'angle max à 45 et c'est modifiable

- nous divisons 360 degrés en 4 quadrants et appelons les fonctions lightLeds() pour chacun comme suit:

* y négatif, z positif premier quadrant contrôlera les led de 0 à 5, l'angle sera de 0 à 89

* y négatif, z négatif deuxième quadrant contrôle les leds de 6 à 12, l'angle sera de 89 à 0

* …etc

- à l'intérieur de la fonction lightLeds

* je calcule un angle basé sur les deux axes en utilisant arctangent (vérifiez l'image ci-jointe)

* je calcule ce qui conduit à afficher en utilisant la fonction de carte arduino

* je remets à zéro la bande de led sauf deux led, celle correspondant à la position de led que j'ai calculée avant et une position de led avant (pour montrer un effet de fondu)

* j'utilise une fonction appelée normalizeLedPosition() pour prendre en compte le calibrage des néopixels. L'étalonnage est utile car la bague néopixel peut être tournée à volonté et doit être alignée avec le gyroscope

* j'imprime également l'axe de remorquage, quelle led a la lumière et l'angle

Les maths

J'ai joint une photo avec l'anneau led et la fonction trigonométrique utilisée pour déterminer l'angle.