En utilisant une LED RGB pour détecter les couleurs (4 / 6 étapes)

Étape 4: Code de l’Arduino

Ouvrez l’environnement Arduino et créer une nouvelle esquisse en cliquant sur fichier - nouveau. Pour ceux qui ne veulent pas suivre le long, j’ai inclus le code dans un fichier texte. Copier/coller dans une nouvelle esquisse dans l’Arduino, et vous êtes bon pour aller.

Déclarations

Le début d’une esquisse est où nous faisons nos déclarations, alors tapez le code suivant dans la fenêtre de l’environnement.

/ / Define couleur broches de capteur LED
int ledArray [] = {2,3,4} ;

Boolean de savoir si l’équilibre a été réglé
balanceSet booléen = false ;

détenteurs de la place pour couleur détecté
rouge int = 0 ;
vert int = 0 ;
bleu int = 0 ;

flotteurs pour tenir les tableaux de couleur
float [] colourArray = {0,0,0} ;
float [] whiteArray = {0,0,0} ;
float [] blackArray = {0,0,0} ;

espace réservé pour les moyenne
int avgRead ;
' / /' est réservé aux commentaires notés, donc vous n’avez pas besoin du texte sur les lignes commençant par ' / /' pour le sketch de travailler.

Le reste sont des noms que nous donnons à certains espaces réservés et les déclarations pour quel genre de données qu’ils contiennent.

Comme vous pouvez le voir, nous commençons en mettant en place un tableau pour contenir les codes pin. Ceux-ci correspondent aux broches connectées à la LED de couleur différente sur l’Arduino.

Ensuite, nous déclarons une valeur booléenne pour vérifier si oui ou non l’équilibrage a été effectuée. Une valeur booléenne est quelque chose qui retourne true ou false.

Nous continuons à créer certains détenteurs de place pour les valeurs de couleur et quelques tableaux d’utiliser pour contenir les données de numérisation et équilibrer la couleur détectée.

Bien que nous n’avons pas encore finis, allez-y et enregistrer votre dessin. Donnez-lui un nom significatif pour vous, quelque chose comme coloursensor.pde peut-être.

Programme d’installation

La prochaine étape dans la création d’une esquisse de l’Arduino est d’écrire la fonction de réglage. Installation est exécutée lorsque l’Arduino démarre tout d’abord, donc c’est où nous dire l’Arduino quoi comment nous voulons utiliser les broches et à installer les autres fonctionnalités que nous pouvons avoir besoin par exemple de communication série.

Tapez la commande suivante sous le code que vous venez d’entrer.

void setup() {}

configurer les sorties pour le capteur de couleur
pinMode(2,OUTPUT) ;
pinMode(3,OUTPUT) ;
pinMode(4,OUTPUT) ;

commencer la communication série
Serial.Begin(9600) ;

}
Pas grand chose à cette section. Ici nous sommes juste dire l’Arduino que nous projetons sur l’utilisation de broches 2, 3 et 4 comme sorties. C’est nécessaire si nous voulons nos voyants... et nous le faisons, serait-ce que très brièvement.

La prochaine partie consiste à dire l’Arduino qui nous avons l’intention d’utiliser le port série, et qu’il devrait être ouvert et prêt à communiquer à la vitesse de transmission spécifiée (entre parenthèses).

Boucle

La fonction de boucle est généralement là que la magie opère dans un Arduino. C’est le code qui s’exécute encore et encore une fois que l’Arduino est démarré et le programme d’installation a été traversé. Mettre le bit de code sous votre fonction de réglage suivant.
void loop() {}

checkBalance() ;
checkColour() ;
printColour() ;
}
Bon à première vue, il semble qu’il y a vraiment pas beaucoup là. Mais ce sont chacun des appels pour des réceptions privées. Pour certains projets, je trouve ce type d’approche fonctionne bien. Il le rend plus facile à lire (je pense) que chaque bloc de code est séparé avec un nom significatif, et nous pouvons voir ce que l’esquisse est va faire un coup de œil.

Tout d’abord il va vérifier l’équilibre, puis il va vérifier la couleur, et puis elle s’imprimera la couleur sur le port série afin que nous pouvons voir les valeurs qu’il lu.

Nous allons explorer la première fonction privée, checkBalance et l’ajouter à notre code. Tapez ce qui suit ci-dessous votre fonction de boucle.
checkBalance() Sub {}
vérifier si l’équilibre a été affectée, sinon, affectez-lui
if(balanceSet == false) {}
setBalance() ;
}
}
Comme vous pouvez le voir, si la valeur balanceSet (valeur booléenne) a la valeur false, puis il effectue un appel à une fonction secondaire, appelée setBalance, où nous avons mis le blanc et noir équilibrage lectures. Cela se produit uniquement lorsque vous démarrez l’arduino l’une fois.
setBalance() Sub {}
régler la balance des blanc
Delay(5000) ;                              délai de cinq secondes, ce qui donne nous le temps d’obtenir un échantillon blanc devant notre capteur
analyse de l’échantillon blanc.
aller à travers chaque lumière, obtenez un résultat, définissez la base de lecture pour chaque couleur rouge, vert et bleu vers le tableau blanc
pour (int i = 0; i < = 2; i ++) {}
digitalWrite(ledArray[i],HIGH) ;
Delay(100) ;
getReading(5) ;          nombre est le nombre d’analyses pour la moyenne, cette fonction entière est redondante, une lecture fonctionne aussi bien.
whiteArray [i] = avgRead ;
digitalWrite(ledArray[i],LOW) ;
Delay(100) ;
}
fait le balayage blanc, maintenant il flashe bleu pour vous dire qu’il est temps pour l’échantillon noir (ou gris).
régler la balance des noir
Delay(5000) ;              attendre cinq secondes donc nous pouvons positionner notre échantillon noir
Allez-y et scan, définit les valeurs de couleur pour rouge, vert et bleu lorsqu’il est exposé au noir
pour (int i = 0; i < = 2; i ++) {}
digitalWrite(ledArray[i],HIGH) ;
Delay(100) ;
getReading(5) ;
blackArray [i] = avgRead ;
blackArray [i] = analogRead(2) ;
digitalWrite(ledArray[i],LOW) ;
Delay(100) ;
}
valeur booléenne afin que nous sachions que l’équilibre est réglé
balanceSet = true ;
Delay(5000) ;     un autre retard 5 secondes pour nous faire rattraper
}
Si vous avez remarqué, nous avons fait un autre appel à une fonction getReading.  Nous ajouterons ce droit après que nous mettons dans la fonction checkColour.

Une fois que nos numéros d’équilibre ont été fixés, nous continuons de lire enfin la couleur. La fonction est essentiellement la même chose que setBalance,, avec l’ajout de la mathématique qui équilibre la lecture. Nous allons ajouter maintenant.
checkColour() Sub {}
pour (int i = 0; i < = 2; i ++) {}
digitalWrite(ledArray[i],HIGH) ;  tour ou le LED, rouge, vert ou bleu selon laquelle itération
Delay(100) ;                      retard pour permettre des CdS à stabiliser, ils sont lents
getReading(5) ;                  Prenez un relevé toutefois de nombreuses fois
colourArray [i] = avgRead ;        définir la couleur actuelle du tableau à la moyenne de lecture
float greyDiff = whiteArray [i] - blackArray [i] ;                    le meilleur rendement possible moins les plus faibles renvoie la surface pour les valeurs dans l’intervalle
colourArray [i] = (colourArray [i] - blackArray [i]) / (greyDiff) * 255 ; la lecture restituée, déduction faite de la valeur la plus basse divisée par le nombre possible multiplié par 255 nous donnera une valeur à peu près entre 0 et 255 qui représente la valeur de la réflectivité actuelle (pour la couleur,) qu'elle est exposée) de ce qui est en cours d’analyse
digitalWrite(ledArray[i],LOW) ;   éteindre la LED actuelle
Delay(100) ;
}


}
Nous aurons également besoin d’ajouter notre fonction getReading, sinon notre croquis n’aura de vraies valeurs. Cette fonction permet juste de prendre quelques lectures et leur moyenne. Cela permet une lecture un peu plus lisse.
{void getReading (int fois)
int de lecture ;
tally int = 0 ;
prendre la lecture mais beaucoup de fois a été demandée et les additionner
pour (int i = 0; i < fois; i ++) {
lire = analogRead(0) ;
Tally = lecture + pointage ;
Delay(10) ;
}
calculer la moyenne et réglez-le
avgRead = (pointage) / times ;
}
Nous avons maintenant une couleur lire dans notre tableau de tenue de couleur, tout ce que nous devons faire maintenant est sortie à l’écran. N’oubliez pas que nous configurons communication série retour dans la fonction de paramétrage, tout ce que nous devons faire maintenant est d’utiliser le port série pour envoyer nos données. L’environnement Arduino inclut un serial monitor, qui vous permettra de voir les données qu’il est passé de l’Arduino. Nous allons donc ajouter la dernière fonction à l’esquisse.
//prints la couleur du tableau de couleur, à l’étape suivante, nous vous enverrons ce traitement pour voir comment bien le capteur fonctionne.
void printColour() {}
Serial.Print ("R =") ;
Serial.println(int(colourArray[0])) ;
Serial.Print ("G =") ;
Serial.println(int(colourArray[1])) ;
Serial.Print ("B =") ;
Serial.println(int(colourArray[2])) ;
Delay(2000) ;
}

Cet exemple affiche quelques données qui ressemble à ceci
R = 231
G = 71
B = 0
ce qui serait l’équivalent d’une couleur rouge-orangé.   J’ai laissé cette esquisse super simple. Vous pouvez habiller comme bon vous semble. L’idée est de montrer comment faire et utiliser le capteur, mise en œuvre créative vous appartient.

Maintenant vous pouvez réenregistrer votre fichier et transférez-le sur l’Arduino. Votre Arduino devrait commencer l’esquisse en cours d’exécution, les petites lumières devraient être vacillante.

L’esquisse est très basique. Je l’ai offert comme un bloc de construction et pour vous montrer comment utiliser le capteur.