Étape 2: OnePixel horloge
En raison de la nature de RVB LED vous ne peut pas produire toutes les couleurs foncées sur eux : il n’y a aucune telle chose comme une LED brun. Vous aussi toujours voudront les couleurs plus riches et plus saturées. Donc ce qu’il nous reste ici est le cercle de spectre de luminosité uniforme, et il faut extraire le maximum de couleurs claires sans équivoque. Ces couleurs doivent être instantanément et sans effort dit dehors : quel usage notre horloge sera du si elle laisse place à aucun doute ? J’ai passé beaucoup de temps à expérimenter, auto persuader et essayer de sortir plus les LED qu’ils peuvent faire et a finalement dû concéder : il y a seulement six couleurs de LED RVB distingués facilement, absolument et sans doute :
Rouge, Orange, vert, Cyan, bleu et Magenta.
Pourquoi pas jaunes et oranges ? Car jaune sur une seule LED ressemble trop à vert et n’est pas facilement identifiable sans référence. Vous pouvez voir par vous-même : écrire un simple croquis en passant un RGB LED rouge (255, 0, 0) au jaune (127, 127, 0) chaque seconde. Vous verrez des couleurs rouges et verts.
Alors que six est un bon nombre de traiter les horloges, il n’était pas raisonnablement suffisant pour mes besoins. Il est possible de serrer quelque chose dans la gamme pourpre, résultant en sept couleurs, mais qui n’aidera pas exactement avec une horloge. J’ai donc décidé d’utiliser un ensemble de dix couleurs supplémentaires pour les tâches où une légère erreur (confusion entre les tons voisins) est acceptable :
Rouge, Orange, jaune, vert, Aquamarine, bleu ciel, bleu, violet, Fuchsia et blanc.
(les noms sont provisoires, bien sûr. Juste de belles paroles. En fait, c’est plutôt de cyan-vert, bleu cyan, bleu-magenta, rouge-magenta, etc.. Consultez la table dans le schéma ci-dessous).
Le blanc est sur cette liste car il n’est pas définitif. Comme il n’est pas une couleur, mais, en fait, l’absence de n’importe quelle teinte, il laisse beaucoup d’imagination et peut être facilement confondu avec autre chose (surtout, cyan). Qui plus est, comme une LED RGB rend blanc hors combinant les trois couleurs de base, en fait ça différemment selon un angle de vision : Si vous regardez la LED d’un point, vous verrez plus de rouge, de l’autre – plus vert etc.
La dernière importante « couleur » (ou, plus exactement, l’absence de celle-ci) est « noir ». Bien qu’il ne peut transmettre aucune information utile (car c’est le même comme une LED éteinte), il est très utile en tant que séparateur.
J’ai donc eu deux séries de couleurs. Au départ, je souhaitais faire une horloge analogique intuitive mais il était clairement de cette époque que je vais devoir coller avec le numérique. Autrement dit, avec affichage des chiffres avec des codes couleurs. Les deux séries sont, bien sûr, idéales pour l’affichage des minutes (ou secondes): l’un de six couleurs peut montrer des dizaines, le dix-couleur est bonne pour ceux (comme ce n'est pas un gros problème si vous confondez les couleurs voisines – vous aurez juste une erreur d’une minute). Juste deux clignotements d’une LED RGB.
Qu’en est-il des heures ? La même approche n’est pas bonne ici : tout d’abord le jeu de 10-couleur n’est pas assez définitif, et Deuxièmement, l’affichage sera plaine terne avec des dizaines de mêmes couleurs à répéter encore et encore. J’ai essayé quelques solutions, mais puis regarda ma montre et il m’a frappé : si la face de l’horloge normale peut diviser le nombre d’heures dans une journée par deux (liste 12 au lieu de 24) alors pourquoi je ne peux pas les diviser davantage ? Après tout, j’ai fais une guirlande, pas une horloge atomique. Et, vraiment, on ne peut confondre 06:00 à minuit ? Ainsi la convention a été faite : un « visage de l’horloge » de mon horloge OnePixel sera de 6 heures, ce qui signifie les mêmes couleurs pour 12 et 6, 1 et 7, 2 et 8, etc. Cette convention s’est avéré très adéquate : la seule fois où je n’étais pas capable de lire l’heure exacte au large de la LED a été le 1er janvier et avaient plus à voir avec le parti d’hiers que n’importe quoi (réveillée, je n’étais pas en mesure de dire si c’est sombre encore ou déjà).
S’il est possible de corréler les chiffres et les couleurs de toute façon, je préfère le faire selon le spectre – pas besoin de mémoriser quoi que ce soit. Voir les graphiques.
En fin de compte l’horloge guirlande montrait de temps en tirets : un pour les longues heures, deux courtes pour les minutes. L’année suivante, j’ai rempli ma maison avec des variations très différentes d’un même appareil, la plupart d'entre eux sportives de plus d’un LED, mais le principe est resté (cocher la vidéo). La seule chose que je ne suis pas sûr de nos jours est la couleur blanche pour 9: Je pense que je devrais faire un peu plus pinkyish pour éviter toute confusion avec le Cyan. Il peut avoir été préférable d’insérer blanc entre deux teintes Cyan du cycle 10-couleur, mais maintenant c’est trop tard pour moi, car je suis déjà assez habitué à ces horloges comme ils sont.
Voici un croquis qui vous permettra de voir l’heure sur une seule LED RGB de 3 manières différentes (modes activés par un bouton ; la volonté mode quatrième être expliquée à l’étape 4). Vous aurez besoin d’un module d’horloge externe. Si vous n’en avez pas vous pouvez utiliser la bibliothèque pour transformer votre Arduino en un dispositif de chronométrage (changer l’esquisse en conséquence). Je suggère que vous obtenez le module RTC si vous avez l’intention de creuser dans les horloges de l’Arduino – c’est vraiment utile et plutôt bon marché.
< p > #include < Wire.h >< br > #define rouge 3 / / broches de la LED RGB est connecté à #define vert 5 #define bleu 6 #define BUTTON_PIN 7 < /p >< p > température int ; octet seconde, minute, heure ; temperPos octets, prevPos, nextPos ; octet r, g, b ; mode octets = 0; < /p >< p > / / onde sinusoïdale tableau const uint8_t lumières [360] = {0, 0, 0, 0, 0, 1, 1, 2, //8 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 15, 17, 18, 20, 22, 24, 26, 28, 30, 32, 35, 37, 39, //32 42, 44, 47, 49, 52, 55, 58, 60, 63, 66 , 69, 72, 75, 78, 81, 85, //48 88, 91, 94, 97, 101, 104, 107, 111, 114, 117, 121, 124, 127, 131, 134, 137, //64 141, 144, 147, 150, 154, 157, 160, 163, 167, 170, 173, 176, 179, 182, 185, 188, //96 191, 194, 197, 200, 202, 205, 208, 210, 213, 215, 217, 220, 222, 224, 226, 229, 231, 232, 234, 236 , 238, 239, 241, 242, 244, 245, 246, 248, 249, 250, 251, 251, 252, 253, 253, 254, 254, 255, 255, 255, 255, 255, 255, 255, 254, 254, 253, 253, 252, 251, 251, 250, 249, 248, 246, 245, 244, 242, 241, 239, 238, 236, 234, 232, 231, 229, 226, 224, 222, 220, 217, 215, 213, 210, 208, 205, 202, 200, 197, 194, 191 , 188, 185, 182, 179, 176, 173, 170, 167, 163, 160, 157, 154, 150, 147, 144, 141, 137, 134, 131, 127, 124, 121, 117, 114, 111, 107, 104, 101, 97, 94, 91, 88, 85, 81, 78, 75, 72, 69, 66, 63, 60, 58, 55, 52, 49, 47, 44, 42, 39, 37, 35, 32, 30, 28, 26, 24, 22, 20, 18, 17, 15 , 13, 12, 11, 9, 8, 7, 6, 5, 4, 3, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} ; un tableau de valeurs de RVB pré-arrangé / / for 10 mm RGB LED. octet RGBready [13] [3] = {{255, 0, 0}, / / heure = 0, min = 0 {229, 26, 0}, / / min = 1 {201, 54, 0}, / / heure = 1 {181, 74, 0}, / / min = 2 {0, 255, 0}, / / heure = 2, min = 3 {0, 218, 36}, / / min = 4 {0, 174, 81}, / / heure = 3 {0, 99, 156}, / / min = 5 {0, 0, 255}, / / heure = 4, min = 6 {74, 0, 181}, / / min = 7 {131 0, 124}, / / heure = 5 {196, 0, 59}, / / min = 8 {95, 78, 81}, / / min = 9}; < /p >< p > / / point de ces tableaux aux couleurs exactes des heures et minutes en RGBready / / je les utilise parce que dans mes projets RGBready peut contenir plus prédisposé / / couleurs que horloge juste (comme le thermomètre). Et il est plus facile. hourColor Byte [6] = {0,2,4,6,8,10} ; minuteColor Byte [10] = {0,1,3,4,5,7,8,9,11,12}; < /p >< p > void setup() {Wire.begin() ; Serial.Begin(9600) ; Serial.println("Starting") ; pinMode (BUTTON_PIN, INPUT_PULLUP) ; le bouton connecte au GND} < /p >< p > void loop() {< /p >< p > / / obtenir et imprimer le temps getTime() ; Serial.Print ("temps est") ; Serial.Print(Hour) ; Serial.Print(":") ; Serial.Print(minute) ; Serial.Print(":") ; Serial.Print(second) ; Serial.println(".") ; heures: % = 6 ; convertir des heures à 6 heures 'visage d’horloge' //hour = minute 6 %; minute = seconde ; < /p >< p > / / pour changer de mode, vous devez appuyez sur et maintenez le bouton / / (la lecture se passe entre les cycles de l’affichage) / / (), j’ai décidé contre ISR ici pour garder l’esquisse au point si! digitalRead(BUTTON_PIN)) mode ++; < /p >< p > mode % = 4 ; Nous avons seulement trois modes < /p >< p > mettre (mode) {case 0: showTimeFades() ; break ; case 1: showTimeTransitions() ; break ; case 2: simpleMode() ; break ; case 3: analogClock() ; break;}} < /p >< p > / / les deux fonctions suivantes sont utilisées pour obtenir le temps d’une puce DS3231 / / ils ont été récupérés à partir de bibliothèque je pense / / la bibliothèque elle-même transforme votre Arduino en une horloge, donc si vous / / n’est pas un module RTC, vous devez le télécharger / / et changer la fonction getTime() pour travailler avec elle void getTime () {/ / l’adresse de puce DS3231 RTC est 0x68 Wire.beginTransmission(0x68) ; Wire.Write(Byte(0)) ; Wire.endTransmission() ; < /p >< p > Wire.requestFrom (0x68, 3, 1) ; demander les trois premiers octets, fermer la connexion deuxième = bcdToDec (Wire.read()) ; minute = bcdToDec (Wire.read()) ; heure = bcdToDec(Wire.read()) ; Nous n’avez pas besoin de renseignements supplémentaires, comme le jour de la semaine, année, etc. / / de l’horloge, alors lisez 3 seulement premiers octets. } < /p >< p > / / convertir décimale codée en binaire des nombres décimaux normal octets bcdToDec(byte val) {return ((val/16 * 10) + (val % 16));} < /p >< p > / / OnePixel The clock modes / / / 1 - le mode, j’ai utilisé sur une showTimeFades() Sub guirlande {int delayVal = 4; / / définit la vitesse globale d’affichage < /p >< p > / / heures de fermeture en fondu fondu couleur pour (int k = 0; k < 241; k ++) {r = (uint16_t)(RGBready[hourColor[hour]][0]*lights[k]) >> 8; g = (uint16_t)(RGBready[hourColor[hour]][1]*lights[k]) >> 8; b = (uint16_t)(RGBready[hourColor[hour]][2]*lights[k]) > > 8 ; setRGBpoint (0, r, g, b) ; Delay(delayVal) ; } < /p >< p > / / couleur de fondu fondu minute-des dizaines de (int k = 0; k < 241; k ++) {r = (uint16_t)(RGBready[hourColor[minute/10]][0]*lights[k]) >> 8; g = (uint16_t)(RGBready[hourColor[minute/10]][1]*lights[k]) >> 8; b = (uint16_t)(RGBready[hourColor[minute/10]][2]*lights[k]) >> 8; setRGBpoint (0, r, g , b); retard (delayVal >> 1) ; deux fois plus rapide que heures} < /p >< p > / / fade fade-out ones-minute color pour (int k = 0; k < 241; k ++) {r = (uint16_t)(RGBready[minuteColor[minute%10]][0]*lights[k]) >> 8; g = (uint16_t)(RGBready[minuteColor[minute%10]][1]*lights[k]) >> 8; b = (uint16_t)(RGBready[minuteColor[minute%10]][2]*lights[k]) >> 8; setRGBpoint (0 r, g, b) ; retard (delayVal >> 1) ; deux fois plus rapide que heures}} < /p >< p > / / 2 - onde sinusoïdale transitions entre couleurs void showTimeTransitions() {int delayVal = 4; / / set transitions vitesse / / fondu pour (int k = 0; k < 121; k ++) {r = (uint16_t)(RGBready[hourColor[hour]][0]*lights[k]) >> 8; g = (uint16_t)(RGBready[hourColor[hour]][1]*lights[k]) >> 8; b = (uint16_t)(RGBready[hourColor[hour]][2]*lights[k]) >> 8; setRGBpoint (0 r, g, b) ; Delay(delayVal) ; } < /p >< p > / / transitions shiftColors (hourColor [heure], hourColor [minute/10], delayVal) ; Delay(50) ; arrêter brièvement sur la RTE-minute valeur shiftColors (hourColor [minute/10], minuteColor [minute % 10], delayVal) ; fermeture en fondu pour (int k = 120; k < 241; k ++) {r = (uint16_t)(RGBready[minuteColor[minute%10]][0]*lights[k]) >> 8; g = (uint16_t)(RGBready[minuteColor[minute%10]][1]*lights[k]) >> 8; b = (uint16_t)(RGBready[minuteColor[minute%10]][2]*lights[k]) >> 8; setRGBpoint (0, r, g, b); delay(delayVal);}} < /p >< p > / / 3 - le mode plus simple possible, peut être utile dans un premier temps pour quelque chose void simpleMode() {int delayVal = 333; r = RGBready [hourColor [heure]] [0]; g = RGBready [hourColor [heure]] [1]; b = RGBready [hourColor [heure]] [2]; setRGBpoint (0, r, g, b); delay(delayVal) ; < /p >< p > r = RGBready [hourColor [minute/10]] [0]; g = RGBready [hourColor [minute/10]] [1]; b = RGBready [hourColor [minute/10]] [2]; setRGBpoint (0 r, g, b) ; Delay(delayVal) ; < /p >< p > r = RGBready [minuteColor [minute % 10]] [0] ; g = RGBready [minuteColor [minute % 10]] [1] ; b = RGBready [minuteColor [minute % 10]] [2] ; setRGBpoint (0, r, g, b) ; Delay(delayVal) ; < /p >< p > setRGBpoint (0, 0, 0, 0) ; retard (delayVal >> 1) ; } < /p >< p > void analogClock() {int delayVal = 8; pour (int k = 0; k < 52; k ++) {r = (float)(RGBready[hourColor[hour]][0]*(60-minute) + RGBready [hourColor [(hour+1) %6]] [0] * minutes) / 60; g = (float)(RGBready[hourColor[hour]][1]*(60-minute) + RGBready [hourColor [(hour+1) %6]] [1] * minutes) / 60; b = (float)(RGBready[hourColor[hour]][2]*(60-minute) + RGBready [hourColor [(hour+1) %6]] [2] * minute) / 60 ; < /p >< p > r = (uint16_t) (r * (lumières [k] * 2 + 30)) >> 8 ; g = (uint16_t)(g*(lights[k]*2+30)) >> 8 ; b = (uint16_t)(b*(lights[k]*2+30)) >> 8 ; setRGBpoint (0, r, g, b) ; Delay(delayVal) ; } pour (int k = 51; k > 0; k--) {r = (float)(RGBready[hourColor[hour]][0]*(60-minute) + RGBready [hourColor [(hour+1) %6]] [0] * minutes) / 60; g = (float)(RGBready[hourColor[hour]][1]*(60-minute) + RGBready [hourColor [(hour+1) %6]] [1] * minutes) / 60; b = (float)(RGBready[hourColor[hour]][2]*(60-minute) + RGBready [hourColor [(hour+1) %6]] [2] * minutes) / 60 ; < /p >< p > r = (uint16_t)(r*(lights[k]*2+30)) >> 8; g = (uint16_t) (g * (lumières [k] * 2 + 30)) >> 8 ; b = (uint16_t)(b*(lights[k]*2+30)) >> 8 ; setRGBpoint (0, r, g, b) ; Delay(delayVal) ; } delay(delayVal*30) ; } < /p >< p > / / fonction de changement de couleur entre / / positions dans le tableau RGBready. Celui-ci utilise le / / onde sinusoïdale algorithme et lumières [] pré-arrangé tableau ci-dessus / / delayVal définit la vitesse de transition shiftColors Sub (ACTU octet, octet suivant, octet delayVal) {uint16_t couleur [3], nextColor [3]; long colorStep [3]; showRGBcolor(cur); / / start avec la couleur claire de première / / calculer les étapes au format unsigned int pour éviter d’utiliser des flotteurs pour (k octets = 0; k < 3; k ++) {couleur [k] = RGBready [Actu] [k] << 8; nextColor [k] = RGBready [suivant] [k] << 8; colorStep [k] = ((long) nextColor [ k] - couleur [k]) / 255 ; } / / set couleurs 120 étapes (360/3), conversion retour octets pour (k octets = 0; k < 120; k ++) {setRGBpoint (0, (color[0]+colorStep[0]*lights[k]) >> 8, (color[1]+colorStep[1]*lights[k]) >> 8, (color[2]+colorStep[2]*lights[k]) >> 8); delay(delayVal);} showRGBcolor(next) ; terminer par Claire deuxième couleur} < /p >< p > / / deux fonctions héritées pour allumer les LEDs. Je les utilise ici pour maintenir la cohérence entre les esquisses de l’exemple / / les deux codes sont pour anode commune LEDs. Si vous utilisez cathode commune ones, / / supprimer les 255-' bits. void setRGBpoint (uint8_t rouge, uint8_t verts, uint8_t LED, uint8_t bleu) {analogWrite (rouge, rouge-255); analogWrite (vert, vert-255); analogWrite (bleu, bleu-255);} < /p >< p > void showRGBcolor (byte chicorée) {analogWrite (rouge, 255-RGBready[curLED][0]) ; analogWrite (vert, 255-RGBready[curLED][1]) ; analogWrite (bleu, 255-RGBready[curLED][2]);} < /p >Remarquez la table des couleurs dans le sketch ? Je vais y revenir dans la dernière étape.
