Met behulp van een RGB-LED te detecteren kleuren (4 / 6 stap)

Stap 4: Code de Arduino

Open de Arduino omgeving, en een nieuwe schets maken door te klikken op bestand - nieuw. Voor degenen die niet willen volgen, heb ik ook de code als een tekstbestand. Copy/Paste het in een nieuwe schets in Arduino, en u bent goed om te gaan.

Verklaringen

Het begin van een schets is waar wij onze verklaringen, dus typt u de volgende code in het venster van de omgeving.

/ / Definiëren colour sensor LED pinnen
int ledArray [] = {2,3,4};

Boole-waarde om te weten als het saldo is vastgesteld
Boole balanceSet = false;

plaats houders voor kleur gedetecteerd
int rood = 0;
int groen = 0;
int blauw = 0;

praalwagens te houden kleur arrays
zweven [colourArray] = {0,0,0};
zweven [whiteArray] = {0,0,0};
zweven [blackArray] = {0,0,0};

place holder voor gemiddelde
int avgRead;
' / /' is voorbehouden voor aangeduid met opmerkingen, dus u hoeft niet de tekst op de regels die met beginnen ' / /' voor de sketch om te werken.

De rest van het zijn een aantal namen die we geven aan sommige tijdelijke aanduidingen, alsmede de verklaringen voor wat voor soort gegevens bevatten.

Zoals u zien kunt, starten we door het opzetten van een matrix te houden van de pin-codes. Deze komen overeen met de pennen die op de verschillende kleur LEDs zijn aangesloten op de Arduino.

Volgende verklaart een Boole-waarde om te controleren of of niet balancing is verricht. Een Booleaanse waarde is iets dat geeft als waar of Onwaar resultaat.

We gaan op sommige houders van de plaats voor de waarden van de kleur, en sommige reeksen te gebruiken voor bewaartermijnen van de gegevens van de scan en het evenwicht van de gedetecteerde kleur te creëren.

Hoewel we nog niet klaar bent, ga je gang en sla uw schets. Geef het een naam die betekenis voor u, zoiets als coloursensor.pde misschien.

Setup

De volgende stap in het creëren van een Arduino schets is te schrijven van de setup-functie. Setup wordt uitgevoerd wanneer de Arduino eerst opstart, dus dit is waar we de Arduino vertellen wat hoe we willen gebruiken van de pinnen en instellen van andere functies die we zoals seriële communicatie wellicht.

Typ het volgende onder de code die u zojuist hebt ingevoerd.

ongeldig Setup {}

opstelling van de uitgangen voor de kleur sensor
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);

beginnen met seriële communicatie
Serial.begin(9600);

}
Niet veel aan dit onderdeel. Hier zijn we gewoon de Arduino vertellen dat we van plan over het gebruik van pin 2,3, en 4 als uitgangen. Dit is nodig als wij willen licht onze LEDs... en we doen, al was het maar heel kort.

Het volgende deel is te vertellen de Arduino die we gebruik maken van de seriële poort willen, en dat het moet worden geopend en gereed is voor communicatie op de baud-rate opgegeven (tussen haakjes).

Loop

De lus functie is meestal waar de magie gebeurt in een Arduino. Het is de code die over en weer wordt uitgevoerd zodra de Arduino is opgestart en vervolgens setup heeft gepasseerd. Zet de volgende beetje van code onder uw setup-functie.
ongeldig loop {}

checkBalance();
checkColour();
printColour();
}
Oke lijkt op het eerste gezicht het alsof er echt er niet veel. Maar deze zijn elke oproepen naar privébijeenkomsten. Voor sommige projecten vind ik dit soort aanpak werkt goed. Het maakt het gemakkelijker te lezen (denk ik) als elk blok van code is gescheiden met een herkenbare naam, en we kunnen zien wat de schets gaat doen in één oogopslag.

Controleer het saldo, zal het eerst vervolgens de kleur zal controleren, en vervolgens zal het de kleur op de seriële poort afdrukken, zodat we kunnen zien dat de waarden die het lezen.

Laten we verkennen de eerste prive-functie, checkBalance, en toe te voegen aan onze code. Typ het volgende onder uw lus functie.
nietig checkBalance() {}
Controleer als het evenwicht heeft zijn ingesteld, zoniet, instellen
if(balanceSet == false) {}
setBalance();
}
}
Zoals u zien kunt, als de waarde van de balanceSet (een Boole-waarde) is ingesteld op false, dan maakt het een aanroep naar een secundaire functie genaamd setBalance, waar we de witte en de zwarte balancing lezingen instellen. Dit zal alleen gebeuren wanneer u opwaarts naar de arduino de ene keer schoen.
nietig setBalance() {}
Stel wit balans in
delay(5000);                              vertraging gedurende vijf seconden, dit geeft ons de tijd om een witte monster voor onze sensor
Scan het witte monster.
Ga door elk licht, krijgen een lezing, de base lezen voor elke kleur rood, groen en blauw aan de witte matrix instellen
for (int i = 0; ik < = 2; i ++) {}
digitalWrite(ledArray[i],HIGH);
delay(100);
getReading(5);          getal is het getal van scans voor gemiddelde te nemen, deze hele functie is overbodig, een lezing werkt net zo goed.
whiteArray [i] = avgRead;
digitalWrite(ledArray[i],LOW);
delay(100);
}
scannen wit gedaan, zal nu het pulse blauw om u te vertellen dat het is tijd voor het monster zwart (of grijs).
Stel zwarte balans
delay(5000);              Wacht vijf seconden zodat we onze zwarte monster kunt plaatsen
Ga je gang en scannen, stelt de kleur waarden voor rood, groen en blauw wanneer blootgesteld aan zwart
for (int i = 0; ik < = 2; i ++) {}
digitalWrite(ledArray[i],HIGH);
delay(100);
getReading(5);
blackArray [i] = avgRead;
blackArray [i] = analogRead(2);
digitalWrite(ledArray[i],LOW);
delay(100);
}
Boole-waarde ingesteld, zodat we weten dat evenwicht is ingesteld
balanceSet = true;
delay(5000);     een andere 5 seconden vertraging te laten inhalen
}
Als u gemerkt, maakte we nog een oproep tot een functie getReading.  Dat recht zullen wij toevoegen nadat we in de checkColour functie gezet.

Zodra onze taakverdeling nummers hebben vastgesteld, gaan we op naar Lees ten slotte de kleur. De functie is in principe hetzelfde als setBalance,, met de toevoeging van de wiskunde dat de lezing balanceert. Laten we nu toevoegen '.
nietig checkColour() {}
for (int i = 0; ik < = 2; i ++) {}
digitalWrite(ledArray[i],HIGH);  beurt of de LED, rood, groen of blauw, afhankelijk van welke iteratie
delay(100);                      vertraging zodat stabalize-cd's, ze zijn traag
getReading(5);                  Neem een lezing echter vele malen
colourArray [i] = avgRead;        instellen van de huidige kleur in de array berekend als het gemiddelde lezen
zweven greyDiff = whiteArray [i] - blackArray [i];                    het hoogst mogelijke rendement minus de laagste retourneert de ruimte voor waarden tussen
colourArray [i] = (colourArray [i] - blackArray [i]) / (greyDiff) * 255; de lezing terug minus de laagste waarde, gedeeld door het mogelijke bereik van de 255 vermenigvuldigd met zal geven ons een waarde ongeveer tussen 0-255 vertegenwoordigen van de waarde voor de huidige reflectiviteit (voor de kleur die het is blootgesteld aan) van wat wordt gescand
digitalWrite(ledArray[i],LOW);   de huidige LED uitschakelen
delay(100);
}


}
We zullen ook moeten toevoegen onze functie getReading, anders onze schets hoeft niet echte waarden. Deze functie kan alleen ons gemiddelde hen uit te nemen van een paar lezingen. Dit zorgt voor een iets soepeler lezing.
void getReading (int keer) {}
int lezen;
int tally = 0;
Neem de lezing echter vele malen werd gevraagd en ze optellen
voor (int i = 0; ik < keer; i ++) {}
lezen = analogRead(0);
Tally = lezing + tally;
delay(10);
}
het gemiddelde berekenen en stel deze
avgRead = (tally) / times;
}
Nu hebben we een kleur lezen in onze kleur bedrijf array, alles wat we moeten doen is nu output naar het scherm. Vergeet niet dat wij seriële communicatie terug in de setup-functie setup, alles wat we moeten doen is nu de seriële poort gebruiken voor het verzenden van onze gegevens. De Arduino omgeving bevat een seriële monitor, die u toelaten zal om de gegevens te bekijken zoals deze wordt doorgegeven van de Arduino. Dus laten we Voeg de laatste functie aan de schets.
//prints de kleur in de array van kleur, in de volgende stap, wij sturen dit naar verwerking om te zien hoe goed de sensor werkt.
ongeldig 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);
}

Dit zal printen enkele gegevens die er als volgt ziet
R = 231
G = 71
B = 0
dat zou het equivalent aan een rood-oranje kleur.   Ik heb deze schets super eenvoudig. U kunt aankleden zoals u goeddunkt. Het idee is om te tonen hoe te maken en gebruiken van de sensor, creatieve uitvoering is aan jou.

U kunt nu het bestand weer opslaan en uploaden naar de Arduino. Je Arduino moet beginnen lopen de sketch, de kleine lampjes flikkeren moeten worden.

De schets is erg basic. Ik heb het aangeboden als een bouwsteen en u tonen hoe te gebruiken van de sensor.