RGB LED spel shield voor arduino (5 / 6 stap)

Stap 5: De code

De code voor dit project is vrij eenvoudig. Het eerste deel is voor defing alles, het tweede voor het maken van een willekeurige kleur, en de derde voor het gebruik van de potentiometers en geven de opdrachten drukknop en LED's.
Hier is het:

/ * Code voor rgb led spel schild. Door Ikestarm17. Speciale dank aan Ladyada voor
alle grote producten, mbeckler voor zijn informatieve site, marklar, grumpy_mike,
en AWOL op de Arduino-forums.* /

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

int redled1 = 19;
int redled2 = 7;
int redled3 = 12;     LED's die tonen als u gelijk hebben of niet waren

int buttonstate;
int val;
int val2;
int val3;
int switchpin = 2;
int switchpin2 = 0;   variabelen voor de knop spullen

int redactual;
int greenactual;
int blueactual;       variabelen voor het opslaan van de kleuren die u wilt aanpassen

int redPin = 3;
int bluePin = 5;
int greenPin = 6;     pinnen voor de rgb geleid hebt u controle over

int redIn = 2;
int greenIn = 3;
int blueIn = 4;       pinnen voor de potentiometers voor de rgb led

int redguess;
int greenguess;
int blueguess;        variabelen voor het opslaan van de waarden van uw led te vergelijken met de willekeurige degenen

/ * Dit volgende deel vóór "ongeldig Setup"
* is alles over het maken van de rgb led
* een "goede" willekeurige kleur, niet alleen een whited uit.
* Ik weet niet veel over dit onderdeel,
* omdat ik veranderd slechts een klein deel,
* Marklar van de forums van de arduino gemaakt * /

#ifndef RGBCommonLED_H
#define RGBCommonLED_H

#include "WProgram.h"

Class RGBCommonLED {}
publiek:
RGBCommonLED (int rpin, int gpin, int bpin);
~ RGBCommonLED();

VOID setRGB (byte r, byte g, byte b);
VOID setHSV (byte h, byte s, byte v);
VOID setColor (unsigned long v);
VOID setHue (byte niveau);
VOID setSat (byte niveau);
VOID setVal (byte niveau);

VOID adjHue (int niveau);
VOID adjSat (int niveau);
VOID adjVal (int niveau);

nietig setRandomColor();
nietig setRandomHue();
nietig setRandomSat();
nietig setRandomVal();

VOID setHSVLevel (int sectie, byte niveau);
VOID adjHSVLevel (int sectie, int niveau);
VOID setRandomHSVLevel (int afdeling);

nietig updateLED();

VOID HSVToRGB (unsigned int inHue, unsigned int inSaturation, unsigned int inValue,
unsigned int * of, unsigned int * oG, unsigned int * oB);

VOID RGBToHSV (unsigned int inRed, unsigned int Enforcer, unsigned int inBlue,
unsigned int * oH, unsigned int * oS, unsigned int * oV);

nietig updateHSVFromRGB();

int pinnen [3];

int rgb [3];

int hsv [3];

privé:

Booleaanse hsvSet;
nietig setRGBFromHSV();
nietig setHSVFromRGB();
};

#endif

RGBCommonLED::RGBCommonLED (int rpin, int gpin, int bpin) {}
pinnen [0] = rpin;
pinnen [1] = gpin;
pennen [2] = bpin;
hsvSet = false;
}

RGBCommonLED:: ~ RGBCommonLED() {}
}

VOID RGBCommonLED::setColor (unsigned long 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 = true;
}

VOID RGBCommonLED::setHSVLevel (int sectie, byte graad) {}
updateHSVFromRGB();
HSV [sectie] = niveau;
this -> setRGBFromHSV();
}

VOID RGBCommonLED::setHue (byte niveau) {}
this -> setHSVLevel(0,level);
}

VOID RGBCommonLED::setSat (byte niveau) {}
this -> setHSVLevel(1,level);
}

VOID RGBCommonLED::setVal (byte niveau) {}
this -> setHSVLevel(2,level);
}

VOID RGBCommonLED::adjHSVLevel (int sectie, int graad) {}
updateHSVFromRGB();
int th = hsv [sectie] + niveau;

Als (th < 0) {}
th = 255 + th;
}
anders als (th > 255) {}
th = 255 - th;
}

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

VOID RGBCommonLED::adjHue (int niveau) {}
this -> adjHSVLevel(0,level);
}

VOID RGBCommonLED::adjSat (int niveau) {}
this -> adjHSVLevel(1,level);
}

VOID RGBCommonLED::adjVal (int niveau) {}
this -> adjHSVLevel(2,level);
}

VOID RGBCommonLED::RGBToHSV (unsigned int inRed, unsigned int Enforcer, unsigned int inBlue,
unsigned int * oH, unsigned int * oS, unsigned int * oV)
{
dubbele vals [3];
unsigned char maxc = 0, minc = 0;
dubbele tint, zat, val;

vals [0] = inRed;
vals [1] = inGreen;
vals [2] = inBlue;
rood is ingesteld als maximum en minimum
Als (vals [1] > vals[maxc]) maxc = 1;
Als (vals [2] > vals[maxc]) maxc = 2;
Als (vals [1] < vals[minc]) minc = 1;
Als (vals [2] < vals[minc]) minc = 2;
Val = vals [maxc];
if(vals[maxc]==0)
zat = kleurtoon = 0;
anders
{
SAT=255*(1-(vals[minc]/vals[maxc]));
tint = 60 * ((maxc*2) + (vals [(maxc+1) %3]-vals [(maxc+2) %3]) / (vals [maxc] - vals[minc]));
}
als += 360; tint (kleurtoon < 0) Corrector voor tinten in het bereik 0 -60
* oH = kleurtoon; map(Hue,0,360,0,255);
* oS = zat;
* oV = val;
}

VOID RGBCommonLED::HSVToRGB (unsigned int inHue, unsigned int inSaturation, unsigned int inValue,
unsigned int * of, unsigned int * oG, unsigned int * oB)
{
Als (inSaturation == 0)
{
Achromatische (grijs)
* Of = * oG = * oB = inValue;
}
anders
{
unsigned int scaledHue = (inHue * 6);
unsigned int sector = scaledHue >> 8; sector 0 tot en met 5 rond het kleurenwiel
unsigned int offsetInSector = scaledHue - (sector << 8); positie binnen de sector
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;

schakelaar (sector) {}
Case 0:
* Of = inValue;
* oG = t;
* oB = p;
breken;
Case 1:
* Of = q;
* oG = inValue;
* oB = p;
breken;
Case 2:
* Of = p;
* oG = inValue;
* oB = t;
breken;
Case 3:
* Of = p;
* oG = q;
* oB = inValue;
breken;
Case 4:
* Of = t;
* oG = p;
* oB = inValue;
breken;
standaard: / / case 5:
* Of = inValue;
* oG = p;
* oB = q;
breken;
}
}
}

VOID RGBCommonLED::setRandomColor() {}
this -> setColor ((niet-ondertekende 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 sectie) {}
this -> setHSVLevel (punt, (niet-ondertekende int)random(0x0100));
}

VOID RGBCommonLED::updateHSVFromRGB() {}
this -> setHSVFromRGB();
hsvSet = true;
}
VOID RGBCommonLED::updateLED() {}
analogWrite (deze-> pins [0], rgb[0]);
analogWrite (deze-> pins [1], rgb[1]);
analogWrite (deze-> pins [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, & v);
HSV [0] = map(h,0,360,0,255);
HSV [1] = s;
HSV [2] = v;
hsvSet = true;
}

RGBCommonLED led1(10,11,9);

VOID Setup
{
pinMode (redled1, OUTPUT);
pinMode (redled2, OUTPUT);
pinMode (redled3, OUTPUT);
pinMode (greenled1, OUTPUT);
pinMode (greenled2, OUTPUT);
pinMode (greenled3, OUTPUT);
pinMode (switchpin, INPUT);
pinMode (switchpin2, INPUT); / / instellen van de leds als uitgang en de schakelaar als input
Serial.begin(9600);          Start seriële
randomSeed(analogRead(0));   lezen van analoge pin 0 om willekeurige waarde

LED1.setRandomHue();
LED1.setSat(255);
LED1.setVal(255);
LED1.setRandomColor();
LED1.updateLED();             een willekeurige kleur instellen op de eerste rgb led

buttonstate = digitalRead(switchpin);  Lees de Schakel als

}

void loop {}

redguess = analogRead(redIn);
greenguess = analogRead(greenIn);
blueguess = analogRead(blueIn);               Lees de potentiometers

redguess = kaart (redguess, 0, 1023, 0, 255);
greenguess = kaart (greenguess, 0, 1023, 0, 255);
blueguess = kaart (blueguess, 0, 1023, 0, 255);    verkleinen van de waarden

analogWrite (redPin, redguess);
analogWrite (greenPin, greenguess);
analogWrite (bluePin, blueguess);              Stel de kleurwaarden

redguess = 255 - redguess;
blueguess = 255 - blueguess;
greenguess = 255 - greenguess;                  vaststellen van de waarde van getallen dus 0 255 en 255 is is 0

Val = digitalRead(switchpin);
delay(10);
val2 = digitalRead(switchpin);
val3 = digitalRead(switchpin2);               schakelaars te lezen en op te lossen het stuiteren

Als (val3 == LOW & & val == val2 & & val! = buttonstate & & val == LOW & & redactual + 55 < redguess ||
val3 == LOW & & val == val2 & & val! = buttonstate & & val == LOW & & redactual - 55 > redguess ||
val3 == LOW & & val == val2 & & val! = buttonstate & & val == LOW & & blueactual + 55 < blueguess ||
val3 == LOW & & val == val2 & & val! = buttonstate & & val == LOW & & blueactual - 55 > blueguess ||
val3 == LOW & & val == val2 & & val! = buttonstate & & val == LOW & & greenactual + 55 < greenguess ||
val3 == LOW & & val == val2 & & val! = buttonstate & & val == LOW & & greenactual - 55 > greenguess ||
val3 == HIGH & & val == val2 & & val! = buttonstate & & val == LOW & & redactual + 85 < redguess ||
val3 == HIGH & & val == val2 & & val! = buttonstate & & val == LOW & & redactual - 85 > redguess ||
val3 == HIGH & & val == val2 & & val! = buttonstate & & val == LOW & & blueactual + 85 < blueguess ||
val3 == HIGH & & val == val2 & & val! = buttonstate & & val == LOW & & blueactual - 85 > blueguess ||
val3 == HIGH & & val == val2 & & val! = buttonstate & & val == LOW & & greenactual + 85 < greenguess ||
val3 == HIGH & & val == val2 & & val! = buttonstate & & val == LOW & & greenactual - 85 > greenguess) {/ / Zorg ervoor dat uw led kleuren komen niet overeen met de andere iemands voor het eenvoudiger niveau

digitalWrite (greenled1, LOW), / / rode leds inschakelen
digitalWrite (redled1, hoog),
delay(500),
digitalWrite (redled1, LOW),
digitalWrite (redled2, hoog),
delay(500),
digitalWrite (redled2, LOW),
digitalWrite (redled3, hoog),
delay(500),
digitalWrite(redled3,LOW);
digitalWrite (redled1, hoog),
delay(500),
digitalWrite (redled1, LOW),
digitalWrite (redled2, hoog),
delay(500),
digitalWrite (redled2, LOW),
digitalWrite (redled3, hoog),
delay(500),
digitalWrite(redled3,LOW),
digitalWrite (redled1, hoog),
digitalWrite (redled2, hoog),
digitalWrite (redled3, hoog),
delay(250),
digitalWrite (redled1, LOW),
digitalWrite (redled2, LOW),
digitalWrite (redled3, LOW),
delay(250),
digitalWrite (redled1, hoog),
digitalWrite (redled2, hoog),
digitalWrite (redled3, hoog),
delay(250),
digitalWrite (redled1, LOW),
digitalWrite (redled2, LOW),
digitalWrite (redled3, LOW),
delay(250),
digitalWrite (redled1, hoog),
digitalWrite (redled2, hoog),
digitalWrite (redled3, hoog),
delay(250),
digitalWrite (redled1, LOW),
digitalWrite (redled2, LOW),
digitalWrite (redled3, LOW),
delay(250),
digitalWrite (redled1, hoog),
digitalWrite (redled2, hoog),
digitalWrite (redled3, hoog),
delay(250),
digitalWrite (redled1, LOW),
digitalWrite (redled2, LOW),
digitalWrite (redled3, LOW),
delay(250);
}

terwijl (val3 == LOW & & val == val2 & & val! = buttonstate & & val == LOW & & / / ervoor zorgen dat de knop is ingedrukt
redactual + 55 > = redguess & & redactual - 55 < = redguess & &
blueactual + 55 > = blueguess & & blueactual - 55 < = blueguess & &
greenactual + 55 > = greenguess & & greenactual - 55 < = greenguess ||
val3 == HIGH & & val == val2 & & val! = buttonstate & & val == LOW & &
redactual + 85 > = redguess & & redactual - 85 < = redguess & &
blueactual + 85 > = blueguess & & blueactual - 85 < = blueguess & &
greenactual + 85 > = greenguess & & greenactual - 85 < = greenguess) {/ / Zorg ervoor dat uw led kleuren zijn dicht genoeg bij de andere iemands voor het makkelijk niveau

digitalWrite(redled1,LOW), / / groene leds inschakelen
digitalWrite (greenled1, hoog),
delay(500),
digitalWrite (greenled1, LOW),
digitalWrite (greenled2, hoog),
delay(500),
digitalWrite (greenled2, LOW),
digitalWrite (greenled3, hoog),
delay(500),
digitalWrite (greenled3, LOW),
digitalWrite(redled1,LOW), / / groene leds inschakelen
digitalWrite (greenled1, hoog),
delay(500),
digitalWrite (greenled1, LOW),
digitalWrite (greenled2, hoog),
delay(500),
digitalWrite (greenled2, LOW),
digitalWrite (greenled3, hoog),
delay(500),
digitalWrite (greenled3, LOW),
digitalWrite (greenled1, hoog),
digitalWrite (greenled2, hoog),
digitalWrite (greenled3, hoog),
delay(250),
digitalWrite (greenled1, LOW),
digitalWrite (greenled2, LOW),
digitalWrite (greenled3, LOW),
delay(250),
digitalWrite (greenled1, hoog),
digitalWrite (greenled2, hoog),
digitalWrite (greenled3, hoog),
delay(250),
digitalWrite (greenled1, LOW),
digitalWrite (greenled2, LOW),
digitalWrite (greenled3, LOW),
delay(250),
digitalWrite (greenled1, hoog),
digitalWrite (greenled2, hoog),
digitalWrite (greenled3, hoog),
delay(250),
digitalWrite (greenled1, LOW),
digitalWrite (greenled2, LOW),
digitalWrite (greenled3, LOW),
delay(250),
digitalWrite (greenled1, hoog),
digitalWrite (greenled2, hoog),
digitalWrite (greenled3, hoog),
delay(250),
digitalWrite (greenled1, LOW),
digitalWrite (greenled2, LOW),
digitalWrite (greenled3, LOW),
delay(250);
}
}