RGB LED spelet shield för arduino (5 / 6 steg)

Steg 5: Koden

Koden för detta projekt är ganska enkel. Den första delen är för defing allt, andra för att skapa en slumpmässig färg, och tredje för att använda potentiometrar och ger kommandona tryckknapp och lysdioder.
Här är det:

/ * Kod för rgb ledde spel sköld. Av Ikestarm17. Speciellt tack till Ladyada för
alla fantastiska produkter, mbeckler för hans informativt webbplats, marklar, grumpy_mike,
och AWOL på Arduino forums.* /

int greenled1 = 13.
int greenled2 = 8;
int greenled3 = 4;

int redled1 = 19.
int redled2 = 7.
int redled3 = 12; lysdioder som visar om du var rätt eller inte

int buttonstate;
int val;
int värde2;
int val3;
int switchpin = 2;
int switchpin2 = 0; variabler för knappen grejer

int redactual;
int greenactual;
int blueactual; variabler för att lagra färgerna du vill matcha

int redPin = 3;
int bluePin = 5;
int greenPin = 6; stift för rgb ledde du kontroll

int redIn = 2;
int greenIn = 3;
int blueIn = 4; stift för potentiometrar för rgb ledde

int redguess;
int greenguess;
int blueguess; variabler för att lagra värden för din led att jämföra med de slumpmässiga som

/ * Denna följande del innan "Ogiltig setup()"
* handlar om att göra rgb ledde
* en "bra" random färg, inte bara en whited ut en.
* Jag vet inte mycket om denna del,
därför att jag ändrade bara en liten del,
* Marklar från arduino forum skapade den * /

#ifndef RGBCommonLED_H
#define RGBCommonLED_H

#include "WProgram.h"

klass RGBCommonLED {
offentlig:
RGBCommonLED (int annapetrovic, int gpin, int bpin);
~ RGBCommonLED();

void setRGB (byte r, byte g, byte b);
void setHSV (byte h, byte s, byte v);
void setColor (osignerade långa v);
void ekeva (byte-nivå).
void setSat (byte-nivå).
void setVal (byte-nivå).

void adjHue (int nivå).
void adjSat (int nivå).
void adjVal (int nivå).

void setRandomColor();
void setRandomHue();
void setRandomSat();
void setRandomVal();

void setHSVLevel (int avsnitt, byte nivå);
void adjHSVLevel (int avsnitt, int nivå);
void setRandomHSVLevel (int avsnitt).

void updateLED();

void HSVToRGB (unsigned int inHue, unsigned int inSaturation, unsigned int inValue,
unsigned int * eller, unsigned int * oG, unsigned int * oB);

void RGBToHSV (unsigned int inRed, unsigned int inGreen, unsigned int inBlue,
unsigned int * Åh, unsigned int * oS, unsigned int * oV);

void updateHSVFromRGB();

int stift [3].

int rgb [3].

int hsv [3].

privat:

booleska hsvSet;
void setRGBFromHSV();
void setHSVFromRGB();
};

#endif

RGBCommonLED::RGBCommonLED (int annapetrovic, int gpin, int bpin) {
stift [0] = annapetrovic;
stift [1] = gpin;
stift [2] = bpin;
hsvSet = false;
}

RGBCommonLED:: ~ RGBCommonLED() {
}

void RGBCommonLED::setColor (osignerade långa v)
{
This -> setRGB ((v & 255), ((v >> 8) & 255), (v >> 16) & 255);
}

void RGBCommonLED::setRGB (byte r, byte g, byte b) {
RGB [0] = r;
RGB [1] = g;
RGB [2] = b;
hsvSet = false;
}

void RGBCommonLED::setHSV (byte h, byte s, byte v) {
HSV [0] = h;
HSV [1] = s;
HSV [2] = v;
This -> setRGBFromHSV();
hsvSet = sant;
}

void RGBCommonLED::setHSVLevel (int avsnitt, byte nivå) {
updateHSVFromRGB();
HSV [avsnitt] = nivå.
This -> setRGBFromHSV();
}

void RGBCommonLED::setHue (byte nivå) {
This -> setHSVLevel(0,level);
}

void RGBCommonLED::setSat (byte nivå) {
This -> setHSVLevel(1,level);
}

void RGBCommonLED::setVal (byte nivå) {
This -> setHSVLevel(2,level);
}

void RGBCommonLED::adjHSVLevel (int avsnitt, int nivå) {
updateHSVFromRGB();
int th = hsv [avsnitt] + nivå.

om (th < 0) {
th = 255 + th;
}
annars om (th > 255) {
th = 255 - th;
}

th = constrain(th,0,255);
HSV [avsnitt] = th;
This -> setRGBFromHSV();
}

void RGBCommonLED::adjHue (int nivå) {
This -> adjHSVLevel(0,level);
}

void RGBCommonLED::adjSat (int nivå) {
This -> adjHSVLevel(1,level);
}

void RGBCommonLED::adjVal (int nivå) {
This -> adjHSVLevel(2,level);
}

void RGBCommonLED::RGBToHSV (unsigned int inRed, unsigned int inGreen, unsigned int inBlue,
unsigned int * Åh, unsigned int * oS, unsigned int * oV)
{
dubbel vals [3].
unsigned char maxc = 0, minc = 0;
dubbel nyans, satt, val;

vals [0] = inRed;
vals [1] = inGreen;
vals [2] = inBlue;
rött är inställd som högsta och lägsta
om (vals [1] > vals[maxc]) maxc = 1;
om (vals [2] > vals[maxc]) maxc = 2;
om (vals [1] < vals[minc]) minc = 1;
om (vals [2] < vals[minc]) minc = 2;
Val = vals [maxc];
IF(vals[maxc]==0)
lör = hue = 0;
annat
{
SAT=255*(1-(vals[minc]/vals[maxc]));
nyans = 60 * ((maxc*2) + (vals [(maxc+1) %3]-vals [(maxc+2) %3]) / (vals [maxc] - vals[minc]));
}
om (nyans < 0) nyans += 360; Corrector för nyanser i-60 till 0 utbud
* oH = nyans; Map(Hue,0,360,0,255);
* oS = satt;
* oV = val;
}

void RGBCommonLED::HSVToRGB (unsigned int inHue, unsigned int inSaturation, unsigned int inValue,
unsigned int * eller, unsigned int * oG, unsigned int * oB)
{
om (inSaturation == 0)
{
akromatisk (grå)
* Eller = * oG = * oB = inValue;
}
annat
{
unsigned int scaledHue = (inHue * 6);
unsigned int sektorn = scaledHue >> 8. sektor 0 5 runt färghjulet
unsigned int offsetInSector = scaledHue - (sektorn << 8); position inom sektorn
unsigned int p = (inValue * (255 - inSaturation)) >> 8.
unsigned int q = (inValue * (255 - ((inSaturation * offsetInSector) >> 8))) >> 8.
unsigned int t = (inValue * (255 - ((inSaturation * (255 - offsetInSector)) >> 8))) >> 8.

Växla (sektor) {
fall 0:
* Eller = inValue;
* oG = t;
* oB = p;
bryta;
fall 1:
* Eller = q;
* oG = inValue;
* oB = p;
bryta;
fall 2:
* Eller = p;
* oG = inValue;
* oB = t;
bryta;
fall 3:
* Eller = p;
* oG = q;
* oB = inValue;
bryta;
fall 4:
* Eller = t;
* oG = p;
* oB = inValue;
bryta;
standard: / / mål 5:
* Eller = inValue;
* oG = p;
* oB = q;
bryta;
}
}
}

void RGBCommonLED::setRandomColor() {
Detta -> setColor ((osignerade long)random(0x01000000));
}

void RGBCommonLED::setRandomHue() {
This -> setRandomHSVLevel(0);
}
void RGBCommonLED::setRandomSat() {
This -> setRandomHSVLevel(1);
}
void RGBCommonLED::setRandomVal() {
This -> setRandomHSVLevel(2);
}

void RGBCommonLED::setRandomHSVLevel (int avsnitt) {
This -> setHSVLevel (avsnitt, (osignerade int)random(0x0100));
}

void RGBCommonLED::updateHSVFromRGB() {
This -> setHSVFromRGB();
hsvSet = sant;
}
void RGBCommonLED::updateLED() {
analogWrite (här-> stift [0], det rgb[0]);
analogWrite (här-> stift [1], rgb[1]);
analogWrite (här-> stift [2], rgb[2]);

redactual = rgb [0];
greenactual = rgb [1].
blueactual = rgb [2].

}

void RGBCommonLED::setRGBFromHSV() {
unsigned int h = hsv [0];
unsigned int s = hsv [1].
unsigned int v = hsv [2].
unsigned int r = 0;
unsigned int g = 0;
unsigned int b = 0;
HSVToRGB (h, s, v & r & g & b);
This -> setRGB(r,g,b);
}

void RGBCommonLED::setHSVFromRGB() {
unsigned int r = rgb [0];
unsigned int g = rgb [1].
unsigned int b = rgb [2].
unsigned int h;
unsigned int s;
unsigned int v.

This -> RGBToHSV (r, g, b & h, & s och v);
HSV [0] = map(h,0,360,0,255);
HSV [1] = s;
HSV [2] = v;
hsvSet = sant;
}

RGBCommonLED led1(10,11,9);

void setup()
{
pinMode (redled1, produktionen);
pinMode (redled2, produktionen);
pinMode (redled3, produktionen);
pinMode (greenled1, produktionen);
pinMode (greenled2, produktionen);
pinMode (greenled3, produktionen);
pinMode (switchpin, ingång);
pinMode (switchpin2, ingång); / / ange lysdioderna som output och växeln som indata
Serial.BEGIN(9600); Starta följetong
randomSeed(analogRead(0)); Läs analog pin 0 att få slumpmässiga värde

LED1.setRandomHue();
LED1.setSat(255);
LED1.setVal(255);
LED1.setRandomColor();
LED1.updateLED(); Ange en slumpmässig färg på första rgb ledde

ButtonState = digitalRead(switchpin); Läs avstängningen som

}

void loop() {

redguess = analogRead(redIn);
greenguess = analogRead(greenIn);
blueguess = analogRead(blueIn); Läs potentiometrar

redguess = karta (redguess, 0, 1023, 0, 255);
greenguess = karta (greenguess, 0, 1023, 0, 255);
blueguess = karta (blueguess, 0, 1023, 0, 255); skala ned värdena

analogWrite (redPin, redguess);
analogWrite (greenPin, greenguess);
analogWrite (bluePin, blueguess); Ange färgvärden

redguess = 255 - redguess;
blueguess = 255 - blueguess;
greenguess = 255 - greenguess; fixa värdets nummer så 0 är 255 och 255 är 0

Val = digitalRead(switchpin);
Delay(10);
värde2 = digitalRead(switchpin);
val3 = digitalRead(switchpin2); Läs växlar och fixa den studsande

om (val3 == låg & & val == värde2 & & val! = buttonstate & & val == låg & & redactual + 55 < redguess ||
val3 == låg & & val == värde2 & & val! = buttonstate & & val == låg & & redactual - 55 > redguess ||
val3 == låg & & val == värde2 & & val! = buttonstate & & val == låg & & blueactual + 55 < blueguess ||
val3 == låg & & val == värde2 & & val! = buttonstate & & val == låg & & blueactual - 55 > blueguess ||
val3 == låg & & val == värde2 & & val! = buttonstate & & val == låg & & greenactual + 55 < greenguess ||
val3 == låg & & val == värde2 & & val! = buttonstate & & val == låg & & greenactual - 55 > greenguess ||
val3 == hög & & val == värde2 & & val! = buttonstate & & val == låg & & redactual + 85 < redguess ||
val3 == hög & & val == värde2 & & val! = buttonstate & & val == låg & & redactual - 85 > redguess ||
val3 == hög & & val == värde2 & & val! = buttonstate & & val == låg & & blueactual + 85 < blueguess ||
val3 == hög & & val == värde2 & & val! = buttonstate & & val == låg & & blueactual - 85 > blueguess ||
val3 == hög & & val == värde2 & & val! = buttonstate & & val == låg & & greenactual + 85 < greenguess ||
val3 == hög & & val == värde2 & & val! = buttonstate & & val == låg & & greenactual - 85 > greenguess) {/ / kontrollera att din led färger inte matchar den andra en för den lättare

digitalWrite (greenled1, låg), / / slå på röda lysdioder
digitalWrite (redled1, hög),
Delay(500),
digitalWrite (redled1, låg),
digitalWrite (redled2, hög),
Delay(500),
digitalWrite (redled2, låg),
digitalWrite (redled3, hög),
Delay(500),
digitalWrite(redled3,LOW);
digitalWrite (redled1, hög),
Delay(500),
digitalWrite (redled1, låg),
digitalWrite (redled2, hög),
Delay(500),
digitalWrite (redled2, låg),
digitalWrite (redled3, hög),
Delay(500),
digitalWrite(redled3,LOW),
digitalWrite (redled1, hög),
digitalWrite (redled2, hög),
digitalWrite (redled3, hög),
Delay(250),
digitalWrite (redled1, låg),
digitalWrite (redled2, låg),
digitalWrite (redled3, låg),
Delay(250),
digitalWrite (redled1, hög),
digitalWrite (redled2, hög),
digitalWrite (redled3, hög),
Delay(250),
digitalWrite (redled1, låg),
digitalWrite (redled2, låg),
digitalWrite (redled3, låg),
Delay(250),
digitalWrite (redled1, hög),
digitalWrite (redled2, hög),
digitalWrite (redled3, hög),
Delay(250),
digitalWrite (redled1, låg),
digitalWrite (redled2, låg),
digitalWrite (redled3, låg),
Delay(250),
digitalWrite (redled1, hög),
digitalWrite (redled2, hög),
digitalWrite (redled3, hög),
Delay(250),
digitalWrite (redled1, låg),
digitalWrite (redled2, låg),
digitalWrite (redled3, låg),
Delay(250);
}

medan (val3 == låg & & val == värde2 & & val! = buttonstate & & val == låg & & / / Kontrollera att knappen trycks
redactual + 55 > = redguess & & redactual - 55 < = redguess & &
blueactual + 55 > = blueguess & & blueactual - 55 < = blueguess & &
greenactual + 55 > = greenguess & & greenactual - 55 < = greenguess ||
val3 == hög & & val == värde2 & & val! = buttonstate & & val == låg & &
redactual + 85 > = redguess & & redactual - 85 < = redguess & &
blueactual + 85 > = blueguess & & blueactual - 85 < = blueguess & &
greenactual + 85 > = greenguess & & greenactual - 85 < = greenguess) {/ / kontrollera att din led färger det är nära till andra ens för lätt nivå

digitalWrite(redled1,LOW), / / slå på gröna lysdioderna
digitalWrite (greenled1, hög),
Delay(500),
digitalWrite (greenled1, låg),
digitalWrite (greenled2, hög),
Delay(500),
digitalWrite (greenled2, låg),
digitalWrite (greenled3, hög),
Delay(500),
digitalWrite (greenled3, låg),
digitalWrite(redled1,LOW), / / slå på gröna lysdioderna
digitalWrite (greenled1, hög),
Delay(500),
digitalWrite (greenled1, låg),
digitalWrite (greenled2, hög),
Delay(500),
digitalWrite (greenled2, låg),
digitalWrite (greenled3, hög),
Delay(500),
digitalWrite (greenled3, låg),
digitalWrite (greenled1, hög),
digitalWrite (greenled2, hög),
digitalWrite (greenled3, hög),
Delay(250),
digitalWrite (greenled1, låg),
digitalWrite (greenled2, låg),
digitalWrite (greenled3, låg),
Delay(250),
digitalWrite (greenled1, hög),
digitalWrite (greenled2, hög),
digitalWrite (greenled3, hög),
Delay(250),
digitalWrite (greenled1, låg),
digitalWrite (greenled2, låg),
digitalWrite (greenled3, låg),
Delay(250),
digitalWrite (greenled1, hög),
digitalWrite (greenled2, hög),
digitalWrite (greenled3, hög),
Delay(250),
digitalWrite (greenled1, låg),
digitalWrite (greenled2, låg),
digitalWrite (greenled3, låg),
Delay(250),
digitalWrite (greenled1, hög),
digitalWrite (greenled2, hög),
digitalWrite (greenled3, hög),
Delay(250),
digitalWrite (greenled1, låg),
digitalWrite (greenled2, låg),
digitalWrite (greenled3, låg),
Delay(250);
}
}