Étape 15 : Ma pleine capacité Code
/ * j’ai fait de mon mieux pour corriger la mutilation de ma mise en forme qui s’est passé quand j’ai collé mon code dans la page. Certaines choses avaient même été effacé/non collés !
Il serait sage de vérifier et s’assurer de que quelque chose d’important n’a pas été commentée, une fois que vous l’obtenez dans l’environnement Arduino.
Original compile bien, commentaire, si c’est broken.* /
Capteur1 int = A2 ; cousu pour mon... doigt pointeur
sensor2 int = A3 ; sensor3 int //middle = A4 ; bague int sensor4 = A5 ; Pinky
#include / / yaaap, veulent être comme cela. voir leur uberguide pour savoir comment l’installer dans votre bibliothèque d’arduino.
C’est un processus relativement simple de ~ 3 étape, vaut la peine. Les fichiers et les instructions sont sur le site suivant :
https://Learn.Adafruit.com/Adafruit-neopixel-uber...
Cliquez sur la bannière du fichier « Sketch », puis sélectionnez Ajouter un fichier dans le menu Naviguer vers lequel il est enregistré le fichier .h pour ajouter son onglet à ce projet
public static int PIN = 10 ; Si vous oubliez cela, où il est dit PIN là-bas va te fâche pas le compilateur.
Le numéro est le nom de l’axe sur votre lilypad les données étant envoyé à partir.
ce qui suit est directement de l’exemple de fichier « strandtest »
Paramètre 1 = nombre de pixels dans la bande de
Paramètre 2 = Numéro d’identification (la plupart sont valide)
Paramètre 3 = type de pixel drapeaux, additionner au besoin: (gauche les infos supplémentaires, signifie peu de choses pour moi) bande de Adafruit_NeoPixel = Adafruit_NeoPixel (15, PIN, NEO_GRB + NEO_KHZ800) ;
J’ai 15 pixels, ainsi que le nombre
/******************************************************************** *********************************************************************
* configurer plus *
* *
********************************************************************/
void setup() {}
pour les lampes :
Strip.Begin() ;
Strip.Show() ;
« Initialiser tous les pixels sur « arrêt » »
initialiser une communication série 9600 bits par seconde :
pinMode (Capteur1, entrée) ; affecte à broche de pointeur en tricot potentiomètre d’entrée
digitalWrite (Capteur1, HIGH); //initializes le capteur
pinMode (sensor2, entrée) ; goupille d’ensembles milieu tricot potentiomètre d’entrée
digitalWrite (sensor2, HIGH) ; Initialise le capteur
pinMode (sensor3, entrée) ; anneau d’ensembles tricot broche feuille de potentiomètre d’entrée
digitalWrite (sensor3, HIGH) ; Initialise le capteur
pinMode (sensor4, entrée) ; affecte à broche de pinky tricot potentiomètre d’entrée
digitalWrite (sensor4, HIGH) ; Initialise le capteur
Serial.Begin(9600) ; }
/******************************************************************** *********************************************************************
* *
* fonction principale *
* *
********************************************************************* ********************************************************************/
void loop() {}
int moyen = 8 ; lumière moyenne
int droite = 15 ; lumière de l’extrémité droite (adresse la plus élevée LED)
int gauche = 1 ; lumière de l’extrémité gauche (adresse la plus basse LED)
lire l’entrée sur la broche analogique :
3.3 V est 1024
Est de 0 V 0
« SV » abréviation de « valeur de la sonde »
int SV1 = analogRead(sensor1) ; 300-400 lo 890-950 Salut
int SV2 = analogRead(sensor2) ; 650-700 lo 900-1015 Salut
int SV3 = analogRead(sensor3) ; avg max avg 650-700 min 1000
int SV4 = analogRead(sensor4) ; min 530 max 1024 - avg Salut avg 950 lo 650ish
Si le mélange de couleurs étaient le désir, cartographie 0-250 pour le 300-950, car la valeur d’un RGB par doigt serait cool pinky pourrait certains bizarre aléatoire mélange équations RVB à l’aide de la valeur mappée. hein.
/ * //uncomment cette section pour utiliser la fonction d’impression série et obtenir votre propre doigt gammes des tampons.
afficher la valeur que vous lisez :
Serial.Print ("valeur 1 =") ;
Serial.Print(sensorValue1) ;
Serial.Print ("valeur 2 =") ;
Serial.Print(sensorValue2) ;
Serial.Print ("valeur 3 =") ;
Serial.Print(sensorValue3) ;
Serial.Print ("valeur 4 =") ;
Serial.println(sensorValue4) ;
*/
/********************************************************************
* IF/THEN réponse *
********************************************************************/
définir la plage de réponse maximum à 950, je pense que cela devrait empêcher de TRUE tout ayant répondu au questionnaire.
pour l’instant, je vais devoir haute/basse déterminer... tournage, nombre de répétitions de sons bien. Trop de couleurs ?
uint16_t répète = 2 ; initialisé à deux >> jettent juste numéro appel de fonction !
DOIGT pointeur---> tourner à droite
300-400 lo 890-950 Salut
Si ((SV1 < = 950) & & (SV1 > = 650))
a choisi de 650 depuis le son vers le milieu de mes « bas haut de gamme » et plus « faibles » lectures.
{
Right_then (bande. Color(250,140,0),4,Middle,Right) ; peut changer de couleur ici RVB
}
Si ((SV1 < = 649) & & (SV1 > = 0))
{Right_then (bande. Color(250,0,0),8,Middle,Right) ; }
DOIGT du milieu---> tourner à gauche
650-700 lo 900-1015 Salut
Si ((SV2 < = 950) & & (SV2 > = 775))
{Left_I_go (bande. Color(250,140,0), 4, milieu, gauche) ; }
Si ((SV2 < = 774) & & (SV2 > = 0))
{Left_I_go (bande. Color(250,0,0), 8, milieu, gauche) ; }
L’annulaire---> mignon clin
avg max avg 650-700 min 1000
Si ((SV3 < = 950) & & (SV3 > = 840))
{Notice_me_Cute (bande. Color(0,0,150), 3, à gauche, milieu, droite) ; bleu}
Si ((SV3 < = 839) & & (SV3 > = 0)) //not une grande différence == précision inférieure == je garde les répétitions courtes pour s’assurer que vous peuvent être avertis des tours
{Notice_me_Cute (bande. Color(127,255,0), 5, à gauche, milieu, droite) ; citron vert}
PINKY---> meh
min 530 max 1024 - avg Salut avg 950 lo 650ish 650 + (950-650) / 2 = valeur du milieu je choisis
Si ((SV4 < = 960) & & (SV4 > = 800))
{dualFade (gauche, droite);}
Si ((SV4 < = 799) & & (SV4 > = 0))
{dualFade2 (gauche, droite);}
/********************************************************************
* clin défaut *
********************************************************************
/ plus tard, peut essayer de le faire celui « mignon » en ayant un compteur générique, disant : compteur ++ ; chaque boucle,
et en utilisant un % 8 pour être difficile de faire un autre changement de variable entre 1-7
.. .et permutation entre + et - ? pourriez avoir besoin d’une troisième variable existant dans le "si 8 % == 0" pour aller %2 avec ont imbriqué instruction sur +/-
« avis me »
pour (int i = gauche ; j’ai > = right; i ++)
{//strip.setPixelColor(pixel#,(R,G,B) défini en fonction d’alimentation)
strip.setPixelColor(i,255,215,0) ; couleur « or »
Strip.Show() ;
}
Delay(300) ;
Mettez à l’extérieur des supports pour essayer d’avoir des lumières allumer sur "all at once" séjour puis un peu
maintenant le désactiver
pour (int i = right ; j’ai > = gauche; i--)
{/ / strip.setPixelColor(pixel#,R,G,B) ;
strip.setPixelColor(i,0,0,0) ;
Strip.Show() ;
}
Delay(300) ;
délai entre lectures/clignote pour la stabilité (a 75 pour l’impression en série.)
> <> <> <> <> <
}
/********************************************************************
* FIN de fonction principale *
********************************************************************
********************************************************************
* *
* CAPTEUR FONCTIONNE!!! *
* *
* J’aime appeler des fonctions, sa façon... NETTOYER!!! *
* *
* Requis : blink a laissé la moitié (pixels 1-8... ou est ce 0-7?) *
* clignoter la moitié droite (pixels 8-15... ou 7-14)? *
* "avis me" clignotent (arc-en-ciel, sûr) *
pour les amuser : lingette arc-en-ciel *
*********************************************************************
* sont mes leds adressée
[1] [2 [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15]
ou [0] [1] [2 [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] ?
Va changer mon for intérieur () itérations *
********************************************************************
* clignotent gauche *
********************************************************************/
void Left_I_go (uint32_t couleur, uint16_t répétitions, milieu int, int gauche)
basé sur colorWipe en strandtest. Voici comment s’appelait le « uint32_t c » dans « main() » 50 était le « attente » !
/ * colorWipe (bande. Color(255, 0, 0), 50) ; Rouge
colorWipe (bande. Color(0, 255, 0), 50); / / vert
colorWipe (bande. Color(0, 0, 255), 50); / / bleu * /
bande. Color(_,_,_),repeats,Middle,Left)
{//variables
attente uint8_t = 20 ;
uint16_t i ;
uint16_t z ; « z » semble différente de celle « i »
veuille à cligner des yeux plusieurs fois, afin de devenir un imbriqués pour boucle
pour (z = 0; z < = répétitions; z ++)
{pour (i = moyen ; j’ai > = gauche; i--)
{
strip.setPixelColor(i,color) ;
Strip.Show() ;
Delay(Wait) ; }
un autre retard pour les garder un peu
Delay(100) ;
maintenant le désactiver
> <> <
pour (i = moyen ; j’ai > = gauche; i--)
{/ / strip.setPixelColor(pixel#,R,G,B) ;
strip.setPixelColor(i,0,0,0) ;
Strip.Show() ;
}
Delay(100) ;
> <> <
}
}
/********************************************************************
* clignoter droit *
********************************************************************/
void Right_then (uint32_t couleur, uint16_t répétitions, milieu int, int droit
) {/ / / bande. Color(_,_,_),repeats,Middle,Right)
variables
attente uint8_t = 20 ; faire court
uint16_t i ;
uint16_t z ;
veuille à cligner des yeux plusieurs fois, afin de devenir un imbriqués pour boucle
pour (z = 0; z < = répétitions; z ++)
{pour (i = moyen ; j’ai < = right; i ++)
{
strip.setPixelColor(i,color) ;
Strip.Show() ;
Delay(Wait) ;
}
un autre retard pour les garder un peu
Delay(100) ;
maintenant le désactiver
> <> <
pour (i = moyen ; j’ai < = right; i ++) //note comment j’ai renversé > à < et--à ++
{
strip.setPixelColor(i,0,0,0) ;
Strip.Show() ;
}
Delay(100) ; }
}
/********************************************************************
* joli clin évincer d’autres employé *
********************************************************************/
HM. peut-être il y a un moyen de, euh... mot. faire la valeur par défaut de cligner des yeux partie de la void loop(), comme mettre il avant que n’importe quelle sonde vérifie, devrait être assez rapidement, droit ? pourrait ajouter un retard. Oui ! Je vais juste faire celui-ci une version fantaisie mignonne, deux feux bounching au large de l’autre au milieu et les extrémités...
void Notice_me_Cute (uint32_t couleur, uint16_t répétitions, int gauche, milieu int, int droit)
{/ / strip. Color(_,_,_),repeats,Left,Middle,Right)
strip.setPixelColor(pixel#,R,G,B) ;
variables
uint8_t attente = 50 ; un peu plus lent que 20 pour le tournage
uint16_t i ;
uint16_t z ;
pour (z = 0; z < = répétitions; z ++)
{
régler et éteindre la lumière centrale
strip.setPixelColor(middle,color) ;
Strip.Show() ;
Delay(Wait) ;
strip.setPixelColor(middle,0,0,0) ;
Strip.Show() ;
maintenant pour le fractionnement
pour (i = 1; i
{
strip.setPixelColor(middle-i,color) ; va à gauche du centre
strip.setPixelColor(middle+i,color) ; va directement du centre
Strip.Show() ; présentés ensemble ?
Delay(Wait) ;
depuis « l’un à la fois » la nécessité d’éteindre les lumières à l’intérieur de la boucle
strip.setPixelColor(middle-i,0,0,0) ;
strip.setPixelColor(middle+i,0,0,0) ;
Strip.Show() ;
}
maintenant pour remonter jusqu’au milieu
recherchant quelques entrée capteur ici serait sage si je veux répéter beaucoup... mais je ne sais pas si c’est possible et comment à
pour (je = 1; i; i--) //did (moyen-1), étant donné que je ne veux pas les bords clignote deux fois, ils sont touchés une fois quand tout le reste sont passés deux fois dans un cycle.
{
strip.setPixelColor(middle-i,color) ; Cela devrait aller à droite de gauche
strip.setPixelColor(middle+i,color) ; et cette gauche de droite
Strip.Show() ;
Delay(Wait) ;
strip.setPixelColor(middle-i,0,0,0) ;
strip.setPixelColor(middle+i,0,0,0) ;
Strip.Show() ; }
}
}
/********************************************************************
* dualFade (meh!) *
4ème option serait plutôt cool pour attacher son ou autre chose.
********************************************************************
/ quelque chose à jeter sur l’auriculaire car je ne peux pas obtenir l’arc-en-ciel fonctions dans la strandtest de travailler.
void dualFade (int gauche, int droit)
{
pour (int i = 0; i < 255 ; j’ai = i + 1)
{
pour (int k = gauche; k < = right; k ++)
{
fracture de l’int = k 2 %;
Si (diviser == 0)
strip.setPixelColor (k, i, 0, 255-i) ;
d’autre
strip.setPixelColor (k, 0, i, 255-i) ;
Delay(10) ;
Strip.Show() ; }
}
}
/********************************************************************
* meh 2 *
********************************************************************
/ void dualFade2 (int gauche, à droite int)
{pour (int i = 0; j’ai < 255; i = i + 1) {}
pour (int k = gauche; k < = right; k ++)
{int fracture = k 2 %;
Si (diviser == 0)
strip.setPixelColor (k, i, 255-i, 0) ;
d’autre
strip.setPixelColor (k, 0, 255-i, i) ;
Delay(10) ;
Strip.Show() ;
}
}
}
