Interaktiva LED labbrock (8 / 11 steg)

Steg 8: Arduino kod

Din kappa kan lysa upp svar på valfritt antal sensorer som kan kopplas till en Arduino. I exempelkoden hittar du en accelerometer (så att den blinkar när du går och dansa) mikrofon (så att den blinkar när du talar) och en distansera sensor (att glöda ljusare som saker tillvägagångssätt). Men med alla olika sensorer kan du ansluta till en Arduino, det finns egentligen ingen gräns för vad du kan göra din kappa reagerar på. Du kan ansluta en temperatursensor till göra din kappa glöda mer rött som du värmer upp. Du kan använda en hall effekt sensor för att göra en kappa som lyser för att varna dig om det osynliga magnetfält. Det är inte som vi någonsin har wired en sensor för alkohol till en av dessa skikt för att förvandla en person till en glöd-in-the-dark breathalizer. Med undantag för att en gång.

Poängen är, ledningar nya sensorer till arduino är det bästa sättet att göra denna kappa din egen. Bli kreativ. Använda exempelkoden nedan som en hoppa från punkt och få kreativ därifrån. Låt oss veta i kommentarerna vad du riggade din kappa att upptäcka!

====================
Koden
====================

medföljande bibliotek
#include < Wire.h >
#include < ADXL345.h >
#include < NewPing.h >

Sonar sensor
#define TRIGGER_PIN 11 / / Arduino PIN-kod knuten till utlösa pin på ultrasonic sensor.
#define ECHO_PIN 10 / / Arduino PIN-kod knuten till echo pin på ultrasonic sensor.
#define MAX_DISTANCE 200 / / maximalt avstånd vi vill skicka ping (i centimeter). Maximal sensorn avståndet är dimensionerade för 400-500cm.

NewPing sonar (TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); NewPing inställning av stift och maximalt avstånd.
int power = 0;
int avstånd = 0;

mikrofon-sensor
int micPin = A3; Välj input PIN-koden för potentiometer

accel + accelRainbow + rainbow
dubbel val = 0,0;
Double valAdjustAccel = 0.0;
Double highvalAccel = 0.0;
Double maxVal = 0.0;
blå, grön, röd;
Double timecounter = 0;
dubbel tc = 200.
ADXL345 adxl; variabla adxl är en instans av ADXL345 biblioteket

PWM lysdioder
int redLED = 5;
int blueLED = 6;
int greenLED = 3;

knappar
int knappen = 7.
int greenButton = 4;
int blueButton = 2;
int rainbowButton = 0;
int off = 8.
int distanceButton = 9;
int micButton = 12;
int accelButton = 13.

andra
int timer = 0;

lägen
int läge = 0; 0 = av, 1 = röd, 2 = blå, 3 = grön, 4 = lila, 5 = kricka, 6 = gul, 7 = vit, 8 = regnbåge
9 = accel blå, 10 = accel grön, 11 = accel röd, 18 = accel rainbow
12 = mic grön, 13 = mic blå, 14 = mic röd
15 = avstånd röd, 16 = avstånd blå, 17 = avstånd grön

mikrofon
int sensorValue = 0; variabel för att lagra värdet kommer från sensorn
Double valAdjustMic = 0.0;
Double highvalMic = 0.0;

void setup() {
Serial.BEGIN(115200); Öppna seriell monitor på 115200 baud
pinMode (redLED, produktionen);
pinMode (blueLED, produktionen);
pinMode (greenLED, produktionen);
pinMode (röda, ingång);
pinMode (greenButton, ingång);
pinMode (blueButton, ingång);
pinMode (rainbowButton, ingång);
pinMode (off, ingång);
pinMode (distanceButton, ingång);
pinMode (micButton, ingång);
pinMode (accelButton, ingång);
adxl.powerOn();
}

void loop() {
readColorButtons();
readAccelButton();
readMicButton();
readDistanceButton();
readOffButton();

lägen: 0 = av, 1 = röd, 2 = blå, 3 = grön, 4 = lila, 5 = kricka, 6 = gul, 7 = vit, 8 = regnbåge
9 = accel blå, 10 = accel grön, 11 = accel röd, 18 = accel rainbow
12 = mic grön, 13 = mic blå, 14 = mic röd
15 = avstånd röd, 16 = avstånd blå, 17 = avstånd grön

om (läge == 0) / / av
{
digitalWrite (redLED, låg);
digitalWrite (greenLED, låg);
digitalWrite (blueLED, låg);
}

om (läge == 1) //red
{
digitalWrite (redLED, hög);
digitalWrite (greenLED, låg);
digitalWrite (blueLED, låg);
}
om (läge == 2) //blue
{
digitalWrite (redLED, låg);
digitalWrite (greenLED, låg);
digitalWrite (blueLED, hög);
}
om (läge == 3) / / grön
{
digitalWrite (redLED, låg);
digitalWrite (greenLED, hög);
digitalWrite (blueLED, låg);
}
om (läge == 4) / / lila
{
digitalWrite (redLED, hög);
digitalWrite (greenLED, låg);
analogWrite (blueLED, 50);
}
om (läge == 5) / / teal
{
digitalWrite (redLED, låg);
digitalWrite (greenLED, hög);
analogWrite (blueLED, 50);
}
om (läge == 6) / / gul
{
digitalWrite (redLED, hög);
digitalWrite (greenLED, hög);
digitalWrite (blueLED, låg);
}
om (läge == 7) / / vit
{
digitalWrite (redLED, hög);
digitalWrite (greenLED, hög);
digitalWrite (blueLED, hög);
}
om (läge == 8) / / rainbow
{
Rainbow();
}
om (läge == 9 || läge == 10 || läge == 11) / / accel blå, grön, röd
{
Accel();
}
om (läge == 12 || läge == 13 || läge == 14) / / mic grön, blå, röd
{
mic();
}
om (läge == 15 || läge == 16 || läge == 17) / / avstånd röd, blå, grön
{
distanceSensor();
}
om (läge == 18) / / accel rainbow
{
accelRainbow();
}

}

void mic() {
Läs värdet från sensorn:
sensorValue = analogRead(micPin);

Serial.println(highvalMic);
valAdjustMic = sensorValue-390;
om (valAdjustMic > highvalMic)
{
highvalMic = valAdjustMic;
}
annat
{
highvalMic = highvalMic*.90;
}
om (highvalMic > maxVal)
// {
maxVal = highvalMic;
// }
IF(highvalMic < 100)
{
highvalMic = 0;
}
om (läge == 14)
{
analogWrite(greenLED,highvalMic);
digitalWrite (blueLED, låg);
digitalWrite (redLED, låg);
}
om (läge == 13)
{
analogWrite(blueLED,highvalMic);
digitalWrite (redLED, låg);
digitalWrite (greenLED, låg);
}
om (läge == 12)
{
analogWrite(redLED,highvalMic);
digitalWrite (blueLED, låg);
digitalWrite (greenLED, låg);
}
Delay(1);
}

void distanceSensor() {
Delay(50); Vänta 50 ms mellan pingmeddelandena (ca 20 ping/SEK). 29ms bör vara den kortaste fördröjningen mellan pingar.
unsigned int oss = sonar.ping(); Skicka ping, ping tid i mikrosekunder (oss) att få.
avståndet = oss / US_ROUNDTRIP_CM;
Serial.Print ("Ping:");
Serial.Print(US / US_ROUNDTRIP_CM); Konvertera ping tid till avståndet i cm och utskriftsresultatet (0 = utanför förutbestämd distans intervall)
Serial.println("cm");

om (avstånd > 29 & & avstånd < 131)
{
Power = (avstånd - 30) * 2,55;
}
om (avstånd < 30 || avstånd > 150)
{
Power = 0;
}
om (avstånd > 130)
{
Power = 255;
}
om (läge == 17)
{
analogWrite(greenLED,power);
digitalWrite (blueLED, låg);
digitalWrite (redLED, låg);
}
om (läge == 16)
{
analogWrite(blueLED,power);
digitalWrite (greenLED, låg);
digitalWrite (redLED, låg);
}
om (läge == 15)
{
analogWrite(redLED,power);
digitalWrite (blueLED, låg);
digitalWrite (greenLED, låg);
}
}

void accel() {
Tråkig accelerometer grejer
int x, y, z;
adxl.readAccel (& x & y, och z); Läs accelerometer värdena och lagra dem i variablerna x, y, z
dubbel dx, dy, dz;
DX = (dubbel) abs (x) / 100;
dy = (dubbel) abs (y) / 100;
DZ = (dubbel) abs (z) / 100;
Val = sqrt((dx*dx)+(dy*dy)+(dz*dz));
Val = sqrt((x*x)+(y*y)+(z*z));
Utgång x, y, z-värden - kommenteras ut
Serial.Print(val);
valAdjustAccel = val-3;
om (valAdjustAccel > highvalAccel)
{
highvalAccel = valAdjustAccel;
}
annat
{
highvalAccel = highvalAccel*.83;
}
om (highvalAccel > maxVal)
// {
maxVal = highvalAccel;
// }
om (highvalAccel * 57 < 4)
{
highvalAccel = 4/57;
}
om (läge == 10)
{
blå = 1;
röd = 0;
grön = 0;
}
om (läge == 9)
{
blå = 0;
röd = 0;
grön = 1;
}
om (läge == 11)
{
blå = 0;
röd = 1;
grön = 0;
}
analogWrite(blueLED,highvalAccel*57*blue);
analogWrite(greenLED,highvalAccel*57*green);
analogWrite(redLED,highvalAccel*57*red);
Delay(30);
}

void accelRainbow() {
Tråkig accelerometer grejer
int x, y, z;
adxl.readAccel (& x & y, och z); Läs accelerometer värdena och lagra dem i variablerna x, y, z
dubbel dx, dy, dz;
DX = (dubbel) abs (x) / 100;
dy = (dubbel) abs (y) / 100;
DZ = (dubbel) abs (z) / 100;
Val = sqrt((dx*dx)+(dy*dy)+(dz*dz));
Val = sqrt((x*x)+(y*y)+(z*z));
Utgång x, y, z-värden - kommenteras ut
Serial.Print(val);
valAdjustAccel = val-3;
om (valAdjustAccel > highvalAccel)
{
highvalAccel = valAdjustAccel;
}
annat
{
highvalAccel = highvalAccel*.83;
}
om (highvalAccel > maxVal)
// {
maxVal = highvalAccel;
// }
om (highvalAccel * 57 < 4)
{
highvalAccel = 4/57;
}

analogWrite(blueLED,highvalAccel*57*blue);
analogWrite(greenLED,highvalAccel*57*green);
analogWrite(redLED,highvalAccel*57*red);
Delay(30);
timecounter = timecounter + 30.

om (timecounter < tc)
{
röd = 1;
blå = 0 + (timecounter) /tc;
}
om (timecounter > 2 * tc & & timecounter < 3 * tc)
{
röd = 1 - (timecounter-2 * tc) /tc;
}
om (timecounter > 4 * tc & & timecounter < 5 * tc)
{
grön = 0 + (timecounter-4 * tc) /tc;
}
om (timecounter > 6 * tc & & timecounter < 7 * tc)
{
blå = 1 - (timecounter-6 * tc) /tc;
}
om (timecounter > 8 * tc & & timecounter < 9 * tc)
{
röd = 0 + (timecounter-8 * tc) /tc;
}
om (timecounter > 10 * tc & & timecounter < 11 * tc)
{
grön = 1-(timecounter-10 * tc) /tc;
}
om (timecounter > 12 * tc)
{
timecounter = 0;
}
Serial.Print(Red);
Serial.Print("");
Serial.Print(Blue);
Serial.Print("");
Serial.Print(Green);
Serial.Print("");
Serial.println(timecounter);

}

void rainbow() {

analogWrite(blueLED,255*blue);
analogWrite(greenLED,255*green);
analogWrite(redLED,255*red);
Delay(30);
timecounter = timecounter + 30.

om (timecounter < tc)
{
röd = 1;
blå = 0 + (timecounter) /tc;
}
om (timecounter > 2 * tc & & timecounter < 3 * tc)
{
röd = 1 - (timecounter-2 * tc) /tc;
}
om (timecounter > 4 * tc & & timecounter < 5 * tc)
{
grön = 0 + (timecounter-4 * tc) /tc;
}
om (timecounter > 6 * tc & & timecounter < 7 * tc)
{
blå = 1 - (timecounter-6 * tc) /tc;
}
om (timecounter > 8 * tc & & timecounter < 9 * tc)
{
röd = 0 + (timecounter-8 * tc) /tc;
}
om (timecounter > 10 * tc & & timecounter < 11 * tc)
{
grön = 1-(timecounter-10 * tc) /tc;
}
om (timecounter > 12 * tc)
{
timecounter = 0;
}
Serial.Print(Red);
Serial.Print("");
Serial.Print(Blue);
Serial.Print("");
Serial.Print(Green);
Serial.Print("");
Serial.println(timecounter);
}

void readColorButtons() {
om (digitalRead (röda) == hög & & digitalRead (greenButton) == låg & & digitalRead(blueButton)==LOW)
{
läge = 1; röd
timer = 0;
}
om (digitalRead (röda) == låg & & digitalRead (greenButton) == låg & & digitalRead(blueButton)==HIGH)
{
läge = 2; blå
timer = 0;
}
om (digitalRead (röda) == låg & & digitalRead (greenButton) == hög & & digitalRead(blueButton)==LOW)
{
läge = 3; grön
timer = 0;
}
om (digitalRead (röda) == hög & & digitalRead (greenButton) == låg & & digitalRead(blueButton)==HIGH)
{
läge = 4; lila
digitalWrite (redLED, hög);
digitalWrite (greenLED, låg);
analogWrite (blueLED, 50);
fördröjning (250);
timer = 0;
}
om (digitalRead (röda) == låg & & digitalRead (greenButton) == hög & & digitalRead(blueButton)==HIGH)
{
läge = 5; Teal
digitalWrite (redLED, låg);
digitalWrite (greenLED, hög);
analogWrite (blueLED, 50);
fördröjning (250);
timer = 0;
}
om (digitalRead (röda) == hög & & digitalRead (greenButton) == hög & & digitalRead(blueButton)==LOW)
{
läge = 6; gul
digitalWrite (redLED, hög);
digitalWrite (greenLED, hög);
digitalWrite (blueLED, låg);
Delay(250);
timer = 0;
}
om (digitalRead (röda) == hög & & digitalRead (greenButton) == hög & & digitalRead(blueButton)==HIGH)
{
läge = 8. Rainbow
digitalWrite(redLED,LOW);
digitalWrite(blueLED,LOW);
digitalWrite(greenLED,LOW);
fördröjning (250);
timer = timer + 250;
}
om (timer == 1500)
// {
läge = 8. regnbågens färger
digitalWrite (redLED, låg);
digitalWrite (blueLED, låg);
digitalWrite (greenLED, låg);
fördröjning (500).
timer = 0;
// }
om (timer == 3000);
// {
läge = 0;
digitalWrite (redLED, låg);
digitalWrite (blueLED, hög);
digitalWrite (greenLED, låg);
Delay(500);
digitalWrite (redLED, låg);
digitalWrite (blueLED, låg);
digitalWrite (greenLED, hög;
Delay(500);
digitalWrite (redLED, hög);
digitalWrite (blueLED, låg);
digitalWrite (greenLED, låg);
Delay(500);
digitalWrite (redLED, låg);
digitalWrite (blueLED, låg);
digitalWrite (greenLED, låg);
timer = 0;
// }
//
}

void readAccelButton() {
om (digitalRead(accelButton)) / / 9 = accel blå, 10 = accel grön, 11 = accel röd, 18 = accel rainbow
{
om (läge == 9) / / redan accel blå
{
läge = 10; göra accel gröna
Delay(500);
}
annars om (läge == 10) / / redan accel grön
{
läge = 11; göra accel röda
Delay(500);
}
annars om (läge == 11) / / redan accel röd
{
läge = 18; göra accel rainbow
Delay(500);
}
annars om (läge == 18) / / redan accel rainbow
{
läge = 9. göra accel blå
Delay(500);
}
annat
{
läge = 9. göra accel blå
Delay(500);
}
}
}

void readMicButton() {
om (digitalRead(micButton)) / / 12 = mic grön, 13 = mic blå, 14 = mic röd
{
om (läge == 12) / / redan mic grön
{
läge = 13. göra mic blå
Delay(500);
}
annars om (läge == 13) / / redan mic blå
{
läge = 14. göra mic röda
Delay(500);
}
annars om (läge == 14) / / redan mic röd
{
läge = 12. göra mic grön
Delay(500);
}
annat
{
läge = 12. göra mic grön
Delay(500);
}
}
}

void readDistanceButton() {

om (digitalRead(distanceButton)) / / 15 = avstånd röd, 16 = avstånd blå, 17 = avstånd grön
{
om (läge == 15) / / redan avstånd röd
{
läge = 16. göra avståndet blå
Delay(500);
}
annars om (läge == 16) / / redan avstånd blå
{
läge = 17; gör avståndet grönt
Delay(500);
}
annars om (läge == 17) / / redan avstånd grön
{
läge = 15. göra avståndet röda
Delay(500);
}
annat
{
läge = 15. göra avståndet röda
Delay(500);
}
}
}
void readOffButton() {
om (digitalRead(offButton))
{
läge = 0;
}
}