Gyroscope amusant avec l'anneau NeoPixel

À propos de ce projet

Dans ce tutoriel, nous utiliserons le MPU6050 gyroscope, un NeoPixel Bague 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 planche à pain. Si vous suivez les étapes, vous construirez ce que vous avez vu dans la vidéo. C'est un bon tutoriel pour en savoir plus sur le gyroscope et l'anneau NeoPixel.

Je construis ce tutoriel en raison de l'intérêt que j'ai vu sur un autre tutoriel de min. Dans ce tutoriel, j'ai remplacé les leds simples par un anneau NeoPixel. 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 :Éléments requis

Pièces

1. Arduino Pro Mini 328P

2. Planche à pain

3. Gyroscope MPU6050

4. 24 anneaux LED NeoPixel

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. Soudure

3. Programmation arduino de base

É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 :au 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 d'alimenter

- en utilisant éventuellement du ruban adhésif en toile, collez le bloc-piles à l'arrière du panneau de commande pour le maintenir en place et le rendre plus portable

Étape 3 :Le code et l'étalonnage

Premier vous devez télécharger et installer deux bibliothèques :

1. Sapin de la bibliothèque de néopixels Adafruit contrôlant le néopixel

2. Bibliothèque MPU6050 pour le gyroscope

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

Plus de détails sur les néopixels ici

Alors 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éfinir vrai 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(); retourner; } if (mpuIntStatus &0x02) { while (fifoCount  0) { lightLeds(y, z, 0, 5, 0, 89); } else if (y <0 et z <0) { lightLeds(y, z, 6, 12, 89, 0); } else if (y> 0 et z <0) { lightLeds(y, z, 13, 19, 0, 89); } else if (y> 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); couleur uint32_t ; for (int i=0; i  position + LED_OFFSET) { return 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(); return true; } void dmpDataReady() { mpuInterrupt =true; }  

Télécharger le code :

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

Connectez l'alimentation (piles)

Calibrage :

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 souhaitez en savoir plus sur son fonctionnement, consultez l'étape suivante

Étape 4 : Comment ça marche (facultatif)

Premier 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.

Le Néopixel 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 à l'aide de 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 le loop() fonction 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 redrawLeds ():

- nous nous concentrons sur deux axes :y, z

- nous contraignons les deux axes de -MAX_ANGLE à +MAX_ANGLE, nous avons défini l'angle max à 45 et il 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 des lightLeds fonction

* 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 aussi l'axe de remorquage, quelle led a de 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.

Code

Le code arduino

Schémas