Veilleuse à changement de couleur à l'aide d'Ardruino 101 : 4 étapes (avec photos)

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

Dans ce projet, vous fabriquerez une lampe de nuit en utilisant ardruino, Adafruit neo rgb Strips et une imprimante 3D.

Notez que cet intrussable est purement pour mon projet d'école. Le code de ce projet est basé sur un autre projet. Cela dit, je ne suis pas un expert en matière d'Ardruino.

Étape 1: Exigences

Pour ce projet, vous aurez besoin du matériel et des outils suivants

Matériel:

1 - Un ardruino101 (aux États-Unis) ou un Genuino101 (pour l'extérieur des États-Unis).

2 - Bandes led NeoPixel rgb de chez adafruit (5 volts).

3 - Un connecteur usb ardruino (connecteur de type B vers A).

4 - Un logiciel d'Ardruino, Ardruino IDE Dans ce tutoriel nous utiliserons la version 1.8.5. Les exigences de la bibliothèque de logiciels sont: 101, Adafruit NeoPixel et Madgwick.

5 -Et un objet pour abriter votre matériel. Dans ce cas, j'utiliserai une imprimante 3D. Le fichier de cette impression 3D se trouve dans les descriptions appelées "Lamp Head". Notez que ce format de fichier n'est pas prêt pour l'impression 3D. En fonction de vos imprimantes 3D, vous devez d'abord exécuter le logiciel d'impression 3D désigné sur l'objet 3D au préalable. Parfois, l'échelle de l'impression 3D se réinitialise. alors assurez-vous que le diamètre est réglé sur 11 cm par 11 cm.

6 - Kit de soudure de base.

Étape 2: Comprendre le matériel et le logiciel

Ardruin/Genuino101

Juste pour clarifier Ardruino101 et genuino101 sont exactement les mêmes à côté des noms. Les deux ont les mêmes spécifications et utilisent le même logiciel.

Ardruino101 possède les spécifications de base comme l'ardruino UNO et plus encore. La principale caractéristique d'ardruino101 est l'accéléromètre et le gyroscope que nous utiliserons dans notre projet. De plus, ce type d'ardruino possède sa bibliothèque de codes unique appelée CurrieIMU (unités de mesure internes) qui est incluse dans l'extension de bibliothèque 101.

Cela dit, parlons du logiciel.

Logiciels et bibliothèques

Ardruino IDE utilise python comme code source principal. c'est aussi la plate-forme de code principale où s'exécute la plupart des ardruino. Il existe de nombreux tutoriels en ligne sur la façon d'utiliser ce logiciel, je vous recommande donc de les rechercher en premier si vous êtes nouveau dans ce programme.

Cela dit, les bibliothèques que nous utilisons sont les suivantes:

Dans le menu Esquisse, > Inclure la bibliothèque > Gérer les bibliothèques… Dans la zone de saisie de texte, saisissez

- 101 Au standart, l'ardruino 101 n'est pas automatiquement inclus dans l'IDE ardruino. Nous avons besoin de cette extension de bibliothèque pour coder notre type ardruino.

-Adafruit NeoPixel afin de coder nos bandes de pixels Neo.

-Madgwick Afin de lire les données brutes et de calculer ces données brutes, tangage et roulis.

Neo bandes RVB

Le type que j'utiliserai est un type 5 tension ou 5v. Avec ce 5v, je n'ai pas besoin d'une source d'alimentation étendue pour contrôler mes bandes. Au lieu de cela, j'utiliserai mon ardruino comme source d'alimentation pour contrôler et allumer les bandes.

Voici quelques conseils que vous devez connaître avant de vous lancer sur ces bandes.

Vous aurez d'abord besoin d'une bande LED Neodigital RGB d'adafruit. Ce type de bandes est contrôlable à l'aide de codes. Ensuite, vous devez savoir qu'il y a une face arrière et une face avant sur ces bandes. Cette face arrière et face avant est importante pour la soudure. Assurez-vous de souder la face avant où la touche fléchée pointe loin de la pointe.

Voici un guide sur la façon de les utiliser.

Il y a 3 points de soudure que vous devez garder à l'esprit. Connexion à la terre (GND), connexion de tension (V) et connexion à broche (DIN).

Étape 3: Configuration des composants

Vous devez d'abord imprimer en 3D le composant que vous pouvez trouver dans les exigences. Dans ce cas, j'utiliserai du PLA. Assurez-vous que le diamètre de l'objet global est de 11 cm sur 11 cm. Cela garantira que l'ardruino et les bandes s'adapteront dans le shpere. Notez que chaque imprimante 3D utilise des logiciels différents pour calculer son processus d'impression. Cela dit, le fichier que vous utilisez peut être mis à l'échelle différemment, alors gardez cela à l'esprit.

Deuxièmement, après l'impression, assurez-vous que les composants peuvent se fermer. Les impressions 3D forment ensemble une sphère. Ils devraient bien s'adapter. Si le composant doit perdre, ajoutez du ruban adhésif sur le côté intérieur pour que le capuchon soit rempli. Et s'il est trop épais, utilisez du papier de verre.

Troisièmement, les skematichs pour l'ardruino et les bandes sont assez faciles. Vous utiliserez 3 fils pour connecter les bandes à l'ardruino. Notez que les seuls endroits que je soude sont sur les bandes. pas sur l'Ardruino lui-même.

GND va à GND

DIN va à un Pin (dans notre cas pin6 sur l'ardruino)

5V passe à 5V

Assurez-vous que la quantité de bandes LED que vous utilisez est plafonnée à 30. Plus cela et il ne parviendra pas à exécuter correctement le code. Vous pouvez simplement couper toutes les bandes inutiles affichées avec un signe de ciseaux.

Quatrième Evrything devrait s'intégrer parfaitement dans la sphère. Vous pourriez comme si je faisais une intersection entre 1 de l'impression 3D afin de voir l'auge et placer une auge en plastique sur le dessus.

Étape 4: Codage

Donc, à présent, vous devriez avoir tous les composants nécessaires dans votre bibliothèque.

Voici le code dont vous aurez besoin pour exécuter le projet. Le résultat devrait ressembler au lien vidéo que j'envoie dans cette page.

La source de ce code peut être trouvée ici. Ce projet comprend également les étapes nécessaires pour mieux comprendre le code et l'algorithme derrière les usages.

#include #include #include #include

#define PIN 6 // Bande NeoPixel 11 pixels

#define PIN1 7 // Bande NeoPixel 1 pixel #define NUMPIXELS 30 // Nombre de pixels #define SAMPLE_RATE 25 // Taux d'échantillonnage pour accéléromètre et gyroscope

// Configuration de Madgwick

filtre de Madgwick; microsPerReading long non signé, microsPrevious; float accelScale, gyroScale;

// Configuration NeoPixel

Pixels Adafruit_NeoPixel = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); Adafruit_NeoPixel pixelsStatus = Adafruit_NeoPixel (1, 7, NEO_GRB + NEO_KHZ800);

// Espaces colorimétriques

RGBConverter RGBConverter; double h = 1; double s = 1; double v = 1; octet rgb[3];

// Témoin de mouvement d'état

// State 0 -> Select Hue - Pitch // State 1 -> Select Saturation - Roll // State 2 -> Select Value - Yaw // State 3 -> Fix color volatile int statusLamp = 0;

void setup() {

Serial.begin(9600);

// démarre l'IMU et filtre

CurieIMU.begin(); CurieIMU.setGyroRate(SAMPLE_RATE); CurieIMU.setAccelerometerRate(SAMPLE_RATE); filter.begin(SAMPLE_RATE);

// Réglez la plage de l'accéléromètre sur 2G

CurieIMU.setAccelerometerRange(2); // Définir la plage du gyroscope à 250 degrés/seconde CurieIMU.setGyroRange(250);

CurieIMU.autoCalibrateAccelerometerOffset(X_AXIS, 0);

CurieIMU.autoCalibrateAccelerometerOffset(Y_AXIS, 0); CurieIMU.autoCalibrateAccelerometerOffset(Z_AXIS, 1); CurieIMU.autoCalibrateGyroOffset();

CurieIMU.attachInterrupt(eventCallback);

CurieIMU.setDetectionThreshold(CURIE_IMU_TAP, 950); CurieIMU.interrupts(CURIE_IMU_TAP);

// initialise les variables pour accélérer les mises à jour pour corriger le taux

microsPerReading = 1000000 / SAMPLE_RATE; microsPrécédent = micros();

// Initialiser NeoPixel 11

pixels.begin(); pixels.show();

// Initialiser NeoPixel 1

pixelsStatus.begin(); pixels.show();

// Afficher l'état en px

setStatusPixel(statusLamp); }

boucle vide() {

int aix, aiy, aiz; //accéléromètre int gix, giy, giz; hache flottante, ay, az; flotteur gx, gy, gz; roulis, tangage, lacet du flotteur; microsNow long non signé statique;

// vérifie s'il est temps de lire les données et de mettre à jour le filtre

microsMaintenant = micros(); if (microsNow - microsPrevious >= microsPerReading) {

// lecture des données brutes de CurieIMU

CurieIMU.readMotionSensor(aix, aiy, aiz, gix, giy, giz);

// conversion des données brutes en unités de gravité et degrés/seconde

ax = convertirAccélérationRaw(aix); ay = convertRawAcceleration(aiy); az = convertRawAcceleration(aiz); gx = convertirRawGyro(gix); gy = convertirRawGyro(giy); gz = convertirRawGyro(giz);

// met à jour le filtre, qui calcule l'orientation

filter.updateIMU(gx, gy, gz, ax, ay, az);

// affiche le cap, le tangage et le roulis

roll = filter.getRoll(); pitch = filter.getPitch(); lacet = filter.getYaw();

// incrémente l'heure précédente, donc nous gardons le bon rythme

microsPrécédent = microsPrécédent + microsPerReading;

// Uniquement si changement Teinte, Saturation ou Valeur

if (statusLamp select Hue if (pitch >= -90 && pitch <= 90 && statusLamp == 0) { // Transformer l'angle pitch = pitch + 90; // Obtient les coordonnées de couleur à partir des angles h = pitch / 180.0; }

// Restrictions d'angles

// roll only -90º to 90º = 180º // State 1 -> select Saturation if (roll >= -90 && roll <= 90 && statusLamp == 1) { // Transformer l'angle roll = roll + 90; // Obtient les coordonnées de couleur à partir des angles s = roll / 180.0; }

// État 2 -> sélectionnez Valeur

if (statusLamp == 2) { // lacet 0º à 360º v = lacet / 360,0; }

// Convertir en RVB

rgbConverter.hsvToRgb(h, s, v, rgb); /* Serial.print("Couleur: "); Serial.print(h); Serial.print(" - "); Impression.série(s); Serial.print(" - "); Serial.print(v); Serial.println(" ");

Serial.print("Orientation: ");

Serial.print(lacet); Serial.print(" "); Serial.print(pas); Serial.print(" "); Serial.println(roll); */

// Changer la couleur des pixels

for (int px = 0; px < NUMPIXELS; px++) { pixels.setPixelColor(px, pixels. Color(rgb[0], rgb[1], rgb[2])); pixels.show(); } }

// Afficher l'état en px

setStatusPixel(statusLamp); } }

float convertRawAcceleration(int aRaw) {

// puisque nous utilisons la plage 2G // -2g correspond à une valeur brute de -32768 // +2g correspond à une valeur brute de 32767

float a = (aRaw * 2.0) / 32768.0;

retourner un; }

float convertRawGyro(int gRaw) {

// puisque nous utilisons une plage de 250 degrés/secondes // -250 mappe à une valeur brute de -32768 // +250 mappe à une valeur brute de 32767

flottant g = (gRaw * 250,0) / 32768,0;

retour g; }

static void eventCallback()

{ // Détecter le tap dans tous les axes if (CurieIMU.getInterruptStatus(CURIE_IMU_TAP)) { Serial.print("Tap detected statusLamp: "); Serial.println(statusLamp);

// Changer d'état

statusLamp++;

// Etat initial

if (statusLamp > 3) { statusLamp = 0; } } }

void setStatusPixel(int statusPx)

{ switch (statusPx) { case 0: pixelsStatus.setPixelColor(0, pixelsStatus. Color(150, 0, 0)); pixelsStatus.show(); Pause; cas 1: pixelsStatus.setPixelColor(0, pixelsStatus. Color(0, 150, 0)); pixelsStatus.show(); Pause; cas 2: pixelsStatus.setPixelColor(0, pixelsStatus. Color(0, 0, 150)); pixelsStatus.show(); Pause; cas 3: pixelsStatus.setPixelColor(0, pixelsStatus. Color(0, 0, 0)); pixelsStatus.show(); Pause;

}

}