Lampe de bureau contrôlée par Arduino/App : 6 étapes (avec photos)

2025 Auteur: John Day | [email protected]. Dernière modifié: 2025-01-13 06:57

Pour ce projet, je voulais quelque chose qui me permettrait d'en apprendre davantage sur l'électronique/les logiciels, quelque chose que je n'ai pas encore vraiment abordé. J'ai décidé qu'une lumière serait une bonne plate-forme pour cela.

Le design que j'ai proposé était celui d'un uplighter doté d'un réglage de la couleur et de la luminosité. Sur le produit, la température de couleur et la luminosité du blanc chaud à froid sont contrôlées via la « rondelle », sa position et son orientation les changeant indépendamment - une interaction assez unique/amusante.

J'ai également fini par créer une application (pourrait aussi bien me mettre au défi) pour les ajuster, ainsi que pour ajouter des fonctionnalités supplémentaires pour contrôler certaines LED RVB et définir une alarme de lever de soleil. L'alarme de lever de soleil augmente progressivement la luminosité sur 30 minutes pour vous aider à vous réveiller.

Comme il s'agit de mon premier projet Arduino/App, je suppose qu'il y aura certainement de meilleures façons de faire le code, alors allez-y doucement! Ça marche donc je suis content. Si vous avez des suggestions d'améliorations, etc., ce serait bien de les entendre.

Tous les fichiers de ce projet (code d'inventeur arduino/app, graphiques de l'application, etc.) et l'apk de l'application. peut être trouvé sur ce lien.

J'ai participé aux concours Raspberry Pi et FULL SPECTRUM LASER, donc si vous pensez que cela vaut la peine, un vote serait grandement apprécié !!

De quoi as-tu besoin….

Élect. Composants:

• Arduino Micro
• 12 capteurs à effet Hall radiométriques linéaires
• Prise CC
• Alimentation 12V
• 2x LED blanc froid 1W (6000K)
• 2x LED blanc chaud 1W (2800K)
• 4x Néopixels RVB Adafruit
• Pilote à courant constant Sparkfun Picobuck 350mA
• Module Bluetooth HC06
• Carte prototype
• Borniers
• Fils

Matériaux:

• Matériaux de fabrication de moules (carton ou silicone, etc.)
• Résine de coulée de polyuréthane
• Contre-plaqué

Consommables:

• Souder
• Peinture en aérosol
• Papier de verre
• Tasses à mélanger/agitateurs

Outils:

• Fer à souder
• Pistolet à colle
• Pinces/tournevis/couteaux etc.
• Découpeur laser

Logiciel:

• Arduino
• MIT App Inventor (gratuit sur le Web)
• Photoshop ou quelque chose pour créer des graphiques d'application

Étape 1: Capteurs à effet Hall

Pour le contrôle/l'interaction du produit, je cherchais quelque chose d'un peu différent, pas seulement un cadran ou quelque chose.

Après quelques recherches sur différents types de composants électroniques, j'ai trouvé des capteurs à effet hall radiométriques linéaires. Il s'agit essentiellement d'un capteur dont la sortie est affectée par les champs magnétiques. Habituellement, la sortie des capteurs est la moitié de la tension d'entrée. Cependant, lorsqu'un aimant est rapproché de lui, la sortie augmentera jusqu'à la tension d'entrée ou chutera à 0 V (limites de saturation) selon qu'il s'agit du pôle nord ou sud de l'aimant.

J'ai réalisé que je pouvais l'utiliser pour me permettre de contrôler deux réglages différents sur un seul capteur à effet Hall - l'idée de la « rondelle » est née. Un aimant est caché dans la rondelle découpée au laser et contrôlerait la luminosité ou la température de couleur en fonction de l'extrémité faisant face aux capteurs. J'entre dans le code Arduino plus tard, mais je lis essentiellement ces capteurs et je cherche si la sortie est passée au-dessus d'un "déclenchement élevé" ou est tombée en dessous du "déclenchement bas". J'utilise plusieurs capteurs à effet Hall pour me permettre de mapper une température de couleur et une valeur de luminosité spécifiques sur chacun, qui se déclenchent lorsque vous faites glisser la rondelle autour de l'arc.

Étape 2: Matériel électronique

La première étape de ce projet consistait à connecter le matériel électronique. J'ai choisi d'utiliser un Arduino Micro car il possède un bon nombre de broches de lecture analogiques - ce qui me permet d'utiliser plusieurs capteurs à effet Hall pour donner une résolution suffisante pour le réglage des paramètres. Une alimentation 12V DC est répartie entre l'alimentation de l'Arduino et du pilote LED.

L'arc de contrôle utilise 11 capteurs à effet Hall, avec un autre utilisé pour éteindre la lumière. Ceux-ci ont été connectés aux broches A0->A5 et 4, 6, 8, 9, 10, 12. Ils partagent un 5v et un rail/broche de masse communs.

Les LED que j'ai utilisées sont de 1W et nécessitent un pilote à courant constant. Le Sparkfun PicoBuck a été utilisé car il délivre un courant constant de 350 mA jusqu'à 3 canaux de sortie. L'alimentation 12V est connectée aux broches Vin des pilotes. Le pilote a des broches d'entrée pour contrôler le PWM des sorties, celles-ci étaient connectées aux broches 3 et 5 de l'Arduino.

Le module bluetooth était alors connecté. Bluetooth Rx-> Arduino Tx, Tx-> Rx et 5v.ground.

Les LED ont été montées sur une carte séparée. Deux LED blanches froides sont connectées en série, tout comme les chaudes. Ceux-ci se connectent aux sorties 1 et 2 du pilote. Les LED RVB sont des Adafruit Neopixels; ce sont des modules chaînés dont vous pouvez contrôler la couleur et la luminosité individuellement à partir d'une broche Arduino. Ceux-ci se connectent à la broche 11 et aux broches 5V/terre.

Étape 3: Inventeur d'applications

Pour créer l'application, j'ai utilisé MIT App Inventor, c'est gratuit et assez facile à apprendre/utiliser. J'ai d'abord dû créer les écrans/graphiques de l'application - cela peut être fait dans Photoshop, etc. Cela facilite les choses dans App Inventor si vous avez tous les composants qui composent les écrans sous forme d'images/fichiers séparés.

App Inventor a deux vues, il y a l'onglet « Designer » pour les éléments visuels frontaux et l'onglet « Blocs » pour le code.

À l'aide de l'onglet « Designer », j'ai créé les écrans de l'application. Un problème que j'ai trouvé est que le composant Bluetooth ne fonctionne pas sur plusieurs écrans, donc après l'écran "bienvenue", tous les autres (connexion, RVB, température de couleur, alarme) sont tous créés sur le même écran - en fait des couches que j'allume /désactivé.

Les principaux outils que j'ai utilisés sont pour « mise en page/alignement » et « toile ». Un canevas est une zone tactile que vous pouvez afficher sous forme d'image.

Une fois les visuels configurés, il est temps de passer à l'onglet "Blocs" et d'écrire le code. Je vais le décrire brièvement, mais c'est probablement plus facile si vous importez mon fichier dans App Inventor et que vous jouez autour de vous…

Ces premiers blocs sont destinés aux écrans de connexion. Pour permettre à l'application d'essayer de se connecter automatiquement au module Bluetooth Arduinos, je crée et définit une variable à l'adresse de mon HC06. J'utilise une minuterie pour changer l'image d'arrière-plan pendant la connexion. Si la connexion est réussie, il charge l'écran de température de couleur. Si le Bluetooth ne parvient pas à se connecter automatiquement, vous devez appuyer sur le bouton « connecter à l'appareil ». Cela fera apparaître une liste de tous les appareils Bluetooth que votre téléphone peut voir. La commande 'bluetoothclient1.connect' utilise l'adresse de périphérique que vous sélectionnez dans cette liste pour vous connecter.

Ces blocs contrôlent ce qui se passe lorsque vous touchez chacun des boutons du menu - basculez entre RVB, température de couleur et alarme. Au fur et à mesure qu'ils sont touchés, les couches visuelles applicables sont activées et désactivées. C'est-à-dire que lorsque vous appuyez sur le bouton de menu RVB, l'image d'arrière-plan du canevas des boutons passe à l'icône sombre, allume l'écran RVB et l'autre s'éteint.

Le contrôle de la puissance et de la luminosité est partagé entre les écrans RVB et de température de couleur. Pour que l'Arduino sache quelles LED contrôler, je dois lui dire quel écran est chargé. Une chaîne de texte au format (écran) ? est envoyé par vos téléphones bluetooth à l'aide de la commande BluetoothClient1. SendText.

Ce bloc envoie la chaîne (Power) ? chaque fois que vous appuyez sur le bouton d'alimentation.

Ces blocs contrôlent le réglage de la température de couleur. Lorsque vous touchez la toile, la coordonnée Y de votre point de contact est utilisée pour définir la variable « cool ». La valeur Y est déterminée par la taille des pixels du canevas, donc dans mon cas une valeur comprise entre 0 et 450. J'utilise le multiplicateur pour la convertir en une valeur PWM utilisable (0-255). J'envoie ensuite une chaîne avec cette valeur et un identifiant sous la forme (Tempvalue)?.

Blocs similaires à ceux ci-dessus mais pour le contrôle de la luminosité. En utilisant la coordonnée X cette fois et différents multiplicateurs pour définir la variable 'Bright' sur une valeur comprise entre 10 et 100.

Ces blocs sont pour le contrôle RVB. Il existe une commande appelée « GetPixelColor » qui peut être utilisée pour obtenir une valeur RVB du pixel que votre doigt touche. Il affiche la valeur avec 255 supplémentaires à la fin pour une raison quelconque, donc je travaille un peu pour obtenir la valeur dans le format (RGBredvalue.greenvalue.bluevalue.) ? Encore une fois, cela est ensuite envoyé à l'Arduino, mais avec RVB comme identifiant dans la chaîne.

La section de blocs suivante concerne les paramètres d'alarme. Le premier bloc contrôle ce qui se passe lorsque vous touchez/faites glisser le soleil de haut en bas. Encore une fois, les commandes « obtenir les X et Y actuels » sont utilisées pour obtenir une valeur pour l'endroit où se trouve votre doigt et pour modifier l'image d'arrière-plan en fonction de la hauteur du soleil. La position du soleil détermine également si l'alarme est activée ou désactivée, elle est envoyée par Bluetooth.

Lorsque vous appuyez ou terminez de déplacer le soleil, le sélecteur d'heure s'affiche pour vous permettre de définir une heure d'alarme. La partie principale de ce prochain bloc utilise l'heure actuelle pour calculer le nombre de millisecondes avant le réglage de l'alarme. Cette valeur est ensuite envoyée à l'Arduino

Dans l'étape suivante, je couvre comment l'Arduino lit et utilise les chaînes…

Étape 4: Code Arduino

Comme pour le code de l'application, je vais couvrir cela brièvement….

J'ai d'abord configuré toutes mes variables, en attribuant les capteurs et les LED aux bonnes broches. La sortie des capteurs à effet Hall sera lue à l'aide de la fonction analogRead, donnant une valeur comprise entre 0 et 1023. Comme décrit précédemment, elle sort la moitié en l'absence d'aimants, donc environ 500. J'utilise des variables de déclenchement Low et High pour me permettre de facilement ajuster quand il sait que la rondelle est au-dessus du capteur.

Les néopixels nécessitent une bibliothèque donc c'est défini ici.

La configuration void démarre les séries, pour le Micro, les broches Rx/Tx (bluetooth) utilisent Serial1.. Les broches sont ensuite configurées pour être des entrées ou des sorties et les LED sont éteintes.

Maintenant c'est la boucle principale…

Cette première section vérifie si des données sont reçues de l'application. Serial1.available() lit le numéro de série et obtient le nombre d'octets dans la chaîne. Si c'est > 0, je connais les données entrantes.

Si vous vous en souvenez, toutes les chaînes que j'envoie depuis l'application se terminent par un point d'interrogation…. c'est-à-dire (Bright100) ?

J'utilise la fonction.readStringUntil pour lire les données série jusqu'au point d'interrogation (Bright100) et définir la variable BTstring sur celle-ci. Je vérifie si BTstring se termine par un ')' pour m'assurer que les commandes complètes sont reçues. Si c'est le cas, alors la boucle BluetoothProgram est appelée… ceci est décrit plus bas.

Ce bit suivant contrôle l'alarme de lever de soleil. Fondamentalement, si l'alarme est activée et que l'heure est correcte, les LED commenceront à s'estomper. En raison de la perception logarithmique de la lumière par l'œil humain, il est préférable de faire n'importe quel type de fondu de LED avec une courbe exponentielle plutôt que linéaire. Par conséquent, une équation détermine les valeurs PWM…

Pour éviter que la rondelle n'interfère avec le contrôle de l'application, elle est désactivée lorsque vous utilisez l'application. Pour réactiver la rondelle, vous devez la retirer du produit pendant 5 secondes. Ce bit de code vérifie d'abord si tous les capteurs émettent une valeur en régime permanent (pas d'aimant), puis démarre une minuterie. Au bout de 5 secondes, la variable BTinControl est remise à false.

Le code de la rondelle maintenant. D'abord, les capteurs doivent être lus.

Si la lumière est actuellement éteinte, elle vérifiera si l'un des capteurs est au-dessus ou en dessous des points de déclenchement, c'est-à-dire que la rondelle a été placée sur l'arc. Si c'est le cas, les LED blanches s'estomperont jusqu'à votre dernier réglage, peu importe où vous le placez.

Pour que les LED restent réglées sur votre dernier réglage au lieu de mettre à jour les valeurs associées aux capteurs qu'elle déclenche, la variable MovedSinceStandby est définie sur false. Ce prochain morceau de code vérifie essentiellement si vous avez déplacé la rondelle de sa position initiale d'un montant défini….

Si vous déplacez la rondelle, le 'MainProgram' est appelé pour mettre à jour la luminosité/température de couleur. Ceci est décrit plus bas.

Le dernier bit de cette boucle principale vérifie si la rondelle a été replacée sur le quai de secours - le capteur 12 lit-il une valeur au-dessus/au-dessous d'un point de déclenchement. Si c'est le cas, la LED s'estompe.

La boucle bluetooth:

Comme décrit ci-dessus, lorsque des données sont reçues via Bluetooth, la chaîne est lue. Nous devons maintenant vérifier ce que dit cette chaîne…

Toutes les chaînes, à l'exception de la luminosité, de la température de couleur et du RVB, sont assez faciles à gérer. Vous vérifiez si BTstring est égal au texte envoyé depuis l'application.

Si vous vous en souvenez, chaque fois que vous changez d'écran dans l'application, une commande Bluetooth est envoyée. Ici, nous posons la question et définissons certaines variables sur true ou false afin que nous sachions sur quel écran vous vous trouvez.

Notez qu'à la fin de chaque section, je définis la variable BTinControl sur true et efface la valeur BTstring.

Lorsque vous appuyez sur le bouton d'alimentation dans l'application, les LED s'estompent vers le haut ou vers le bas. Les variables définies ci-dessus pour l'écran sur lequel vous vous trouvez sont utilisées pour décider si ce sont les LED RVB ou blanches à contrôler.

Pour la luminosité, la température de couleur et le RVB, je dois lire les chaînes d'une manière légèrement différente. Parce que la partie numérique de la chaîne changera, je me demande si la chaîne commence par l'un des identificateurs et non par la chaîne complète, donc juste (Bright here..

Je dois maintenant séparer la valeur de luminosité réelle de la chaîne. Le format de la chaîne envoyée depuis l'application est (Brightvalue) donc je sais que la valeur de luminosité sera comprise entre le 't' et le ')'. La position du 't' restera constante, ce sera toujours le 7ème caractère de la chaîne. Mais comme la valeur de luminosité peut être comprise entre 10 et 100, la position du ')' changera. J'utilise la commande.indexOf pour déterminer où se trouve le ')', de quel caractère il s'agit et je peux ensuite utiliser la commande.substring pour lire la chaîne entre le 7ème caractère et la position du caractère ')'. Cela me laisse juste la valeur de luminosité que je peux utiliser pour ajuster les LED RVB ou blanches en fonction de l'écran.

Le réglage de la température de couleur est un processus similaire à ci-dessus, mais la valeur sera comprise entre le 'p' et le ')' cette fois…

Pour le réglage RVB, nous avons trois valeurs à extraire de la chaîne, mais c'est à nouveau un processus similaire. De l'application, nous recevons des chaînes sous la forme (RVBvalue.value.value)

Je sais donc que la valeur rouge sera entre le « B » et le premier point. La valeur verte se situe entre les 1er/2e points et la valeur bleue entre le 2e et le ')'.

Une fois que nous avons les valeurs, les néopixles sont réglés sur la nouvelle couleur…

Ici, nous vérifions si l'alarme est activée ou désactivée. Si l'heure de l'alarme est modifiée, nous recevrons une chaîne avec le nombre de millisecondes à partir de maintenant jusqu'à l'alarme. Encore une fois, cette valeur est extraite de la chaîne et afin de pouvoir vérifier s'il est temps de commencer le lever du soleil, nous devons définir une variable sur l'heure actuelle (millis)..

Contrôles de la rondelle:

Comme décrit précédemment, si la rondelle (aimant) est dans un sens, elle entraînera la sortie du capteur à effet Hall en dessous du déclencheur bas et si dans l'autre sens au-dessus du déclencheur haut.

Cela permet de contrôler à la fois la luminosité et la température de couleur sur le même arc.

Les valeurs des capteurs sont lues. Si l'un d'entre eux est inférieur à la valeur de déclenchement basse, nous ajustons la température de couleur. Il y a 11 capteurs sous la zone de l'arc, dont les sorties passeront à leur tour en dessous du point de déclenchement lorsque la rondelle se déplacera sur eux. Chaque capteur a une valeur PWM pour les LED froides et chaudes, en commençant par le capteur 1 à 100 % chaud, 0 % froid et jusqu'au 11e à 0 % chaud, 100 % froid.

Le contrôle de la luminosité se fait de la même manière. vérifier si les sorties des capteurs sont au-dessus du déclencheur haut cette fois et donner à chaque capteur une valeur de pondération de la luminosité.

Cette pondération de luminosité est ensuite multipliée par la valeur de température de couleur pour donner la valeur de sortie globale. Vous permettant de régler n'importe quelle température de couleur à n'importe quelle luminosité…

Étape 5: Logement

1. J'ai commencé par fabriquer un moule en carton pour la partie inférieure du boîtier. Pour créer les évidements de la zone de contrôle, j'ai fait découper au laser un morceau de contreplaqué en forme d'arc et j'ai utilisé une pièce de 5 pièces pour le quai « de secours ». Ceux-ci ont été collés sur le moule en carton, en veillant à ce qu'ils soient dans la bonne position qui s'alignerait avec les capteurs à effet Hall.
2. Ensuite, il fallait mélanger la résine polyuréthane. Le produit que j'utilise a un rapport simple de 1:1 et durcit en 20 minutes environ… donc il faut travailler assez rapidement !
3. La coulée initiale devait remplir le fond du moule. Après cet ensemble j'ai ajouté une paroi intérieure en carton pour me permettre de couler les parois latérales.
4. Pour créer la section supérieure, dans laquelle les LED seraient assises, j'ai coupé et collé un tube/gobelet en plastique en place à un angle. Et encore une fois, la résine a été versée et laissée prendre.
5. Maintenant que le boîtier était prêt, j'avais besoin de percer quelques trous et de lui donner un bon ponçage.
6. L'apprêt a été appliqué puis pulvérisé avec la dernière couche de peinture de finition.

Étape 6: Assemblage/Conclusion

1. Une fente pour la prise DC a été découpée dans le boîtier. Le cric est ensuite collé.
2. La carte LED peut ensuite être vissée dans la partie supérieure, avec les fils acheminés jusqu'à la partie inférieure.
3. Les fils des LED et de la prise CC ont ensuite été vissés dans les blocs de jonction appropriés.
4. La carte principale est ensuite vissée dans le boîtier
5. Un morceau de contreplaqué est ensuite vissé pour couvrir le fond du boîtier.
6. La dernière chose est de coller la « rondelle » ensemble, en veillant à orienter les pôles de l'aimant avec le bon embout « luminosité » ou « température de couleur ».

Dans l'ensemble, la lumière fonctionne plutôt bien! Il y a quelques bugs dans le logiciel à corriger et les LED RVB pourraient être plus lumineuses. Je peux également ajouter un capteur de lumière ambiante pour changer automatiquement la température de couleur, en commençant « froid » pendant la journée et en passant en « chaud » la nuit.

Bravo pour la lecture !