Använder en RGB LED att upptäcka färger (4 / 6 steg)

Steg 4: Kod Arduino

Deklarationer

I början av en skiss är där vi gör våra deklarationer, så skriv följande kod i fönstret miljö.

för genomsnitt
int avgRead; ' / /' är reserverade för betecknas kommentarer, därför inte behöver du texten på rader som börjar med "/ /" för skissen att arbeta.

Resten av det är några namn som vi ger till några platshållare och deklarationer för vilken typ av data de innehåller.

Som ni ser, börjar vi genom att inrätta en matris att hålla pin-koder. Dessa motsvarar de stift som olika färg lysdioder är anslutna till på Arduino.

Nästa tillkännager vi ett booleskt värde att kontrollera huruvida balansera har utförts. Ett booleskt värde är något som returnerar sant eller falskt.

Vi går att skapa några platshållare för färgvärdena och vissa matriser för hålla Skanna data och balansera den upptäckta färgen.

Även om vi inte är färdiga ännu, gå vidare och spara din skiss. Ge det ett namn som är meningsfulla för dig, något som coloursensor.pde kanske.

Setup

Nästa steg i att skapa en Arduino skiss är att skriva setup-funktionen. Installationsprogrammet körs när Arduino först startar upp, så det är där vi berättar Arduino vad hur vi vill använda stiften och ställa andra funktioner som vi kan behöva som seriell kommunikation.

Skriv följande nedan koden som du just angett. void setup() {

Konfigurera utgångarna för färg sensorn
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);

börja seriell kommunikation
Serial.BEGIN(9600);

} Inte mycket till detta avsnitt. Här säger vi bara till Arduino att vi tänker på att använda stift 2,3 och 4 som resultat. Detta är nödvändigt om vi vill tända våra lysdioder... och vi gör, om så bara helt kort.

Nästa del är att berätta Arduino som vi avser att använda den seriella porten, och att det bör vara öppen och redo att kommunicera på baud anges (inom parentes).

Loop

Loop funktion är normalt där magiskt händer i en Arduino. Det är den kod som körs om och om igen när Arduino startas och installationen har gått igenom. Sätta den nästa bit kod under din setup-funktionen.
void loop() {

checkBalance();
checkColour();
printColour();
} Okej vid första anblicken ser ut som det verkligen inte finns mycket där. Men dessa är varje samtal till privata tillställningar. För vissa projekt hitta jag denna typ av strategi fungerar väl. Det gör det lättare att läsa (tror jag) som varje kodblock är separerade med ett meningsfullt namn, och vi kan se vad skissen ska göra en överblick.

Först det kommer att kontrollera balansen, sedan det kommer att kontrollera färgen, och sedan skriver ut färgen till den seriella porten så vi kan se de värden som det läsa.

Låt oss utforska den första privata funktionen, checkBalance, och lägga till den i vår kod. Skriv följande nedan din loop funktion. void checkBalance() {
Kontrollera om balansen har varit anges, om inte, ange den
IF(balanceSet == false) {
setBalance();
}
} Som du kan se, om den balanceSet (booleskt värde) har värdet FALSKT, då det gör ett anrop till en sekundär funktion kallas setBalance, där vi satt i vitt och svart balansera avläsningar. Detta sker endast när du startar upp arduino en gång. void setBalance() {
ställa in vitbalans
Delay(5000); dröjsmål i fem sekunder, detta ger oss tid för att få en vit urval framför sensor
Skanna den vita provet.
gå igenom varje ljus, få en behandling, som basen läsning för varje färg röd, grön och blå till den vita matrisen
för (int jag = 0; jag < = 2; i ++) {
digitalWrite(ledArray[i],HIGH);
Delay(100);
getReading(5); tal är tal av skanningar att ta för genomsnittet, hela funktionen är överflödiga, en läsning fungerar lika bra.
whiteArray [i] = avgRead;
digitalWrite(ledArray[i],LOW);
Delay(100);
}
gjort scanning vit, kommer nu det puls blå att berätta att det är dags för det svarta (eller grå) provet.
ställa in svart balans
Delay(5000); vänta i fem sekunder så vi kan placera vår svart prov
Varsågod och skanna, sätter färgvärdena för rött, grönt och blått när den utsätts för svart
för (int jag = 0; jag < = 2; i ++) {
digitalWrite(ledArray[i],HIGH);
Delay(100);
getReading(5);
blackArray [i] = avgRead;
blackArray [i] = analogRead(2);
digitalWrite(ledArray[i],LOW);
Delay(100);
}
ställa in booleskt värde så vi vet att balans är inställd
balanceSet = sant;
Delay(5000); fördröja en annan 5 sekunder för att låta oss ikapp
} Om du märkt, vi gjorde ännu ett anrop till en funktion getReading. Vi kommer att lägga till denna rätt efter att vi lagt i funktionen checkColour.

När våra motkontots nummer har ställts in, går vi att äntligen läsa färg. Funktionen är i princip samma som setBalance,, med tillägg av matematik som balanserar behandlingen. Låt oss lägga det nu. void checkColour() {
för (int jag = 0; jag < = 2; i ++) {
digitalWrite(ledArray[i],HIGH); tur eller LED, rött, grönt eller blått beroende vilken iteration
Delay(100); fördröja så att CD-skivor till stabalize, de är långsamma
getReading(5); ta en behandling men många gånger
colourArray [i] = avgRead; Ange den aktuella färgen i matrisen genomsnitt läsning
flyta greyDiff = whiteArray [i] - blackArray [i]; den högsta möjliga avkastningen minus lägsta returnerar området för värden mellan
colourArray [i] = (colourArray [i] - blackArray [i]) / (greyDiff) * 255; den behandlingen återvände minus lägsta värdet dividerat med den möjliga utbud multiplicerat med 255 kommer att ge oss ett värde ungefär mellan 0-255 som representerar värdet för den aktuella reflektionsförmåga (för färgen den utsätts för) av vad är det som skannas
digitalWrite(ledArray[i],LOW); Stäng av den nuvarande LED
Delay(100);
}

} Vi måste också lägga till vår funktion getReading, annars kommer inte vår skiss har verkliga värden. Denna funktion tillåter bara oss att ta några avläsningar och genomsnittlig dem. Detta ger en något mjukare läsning. void getReading (int gånger) {
int läsning;
int tally = 0;
ta behandlingen men många gånger begärdes och lägga upp dem
för (int jag = 0; jag < gånger; i ++) {
läsning = analogRead(0);
Tally = behandlingen + tally;
Delay(10);
}
beräkna medelvärdet och ange det
avgRead = (stämmer) / times;
} Nu har vi en färg läsa i vår färg anläggning array, allt vi behöver göra nu är mata den till skärmen. Kom ihåg att vi setup seriell kommunikation tillbaka i setup-funktionen, allt vi behöver göra nu är använder den seriella porten för att skicka ut våra data. Arduino-miljö innehåller en seriell monitor, vilket gör att du kan se data som den skickas från Arduino. Så låt oss lägga till den sista funktionen på skissen. //prints färg i matrisen färg, i nästa steg, vi skickar detta till behandling för att se hur bra sensorn fungerar.
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);
} Detta kommer att skriva ut vissa data som ser ut ungefär så här R = 231
G = 71
B = 0 vilket skulle vara equivilent till en röd-orange färg. Jag har lämnat denna skiss superenkel. Du kan klä den som du tycker passar. Tanken är att visa hur man gör och använder sensorn, kreativt genomförande är upp till dig.

Nu kan du spara filen igen och ladda upp den till Arduino. Din Arduino bör börja köra skissen, lilla lamporna bör flimmer.

Skissen är mycket grundläggande. Jag har erbjudit det som en byggsten och att visa dig hur du använder sensorn.