Skimrande Chameleon (smart) kjol ~ (1 / 7 steg)
Steg 1: Koden
#include < Wire.h >
#include < Adafruit_TCS34725.h >
#include < Adafruit_LSM303.h >
#include < Adafruit_NeoPixel.h >
Parametern 1 = antal pixlar i remsa
Parameter 2 = pin-kod (de flesta är giltig)
Parameter 3 = pixel typ flaggor, Lägg ihop efter behov:
NEO_RGB pixlar är kopplat för RGB bitstream
NEO_GRB pixlar är kopplat för GRB bitstream
NEO_KHZ400 400 KHz bitstream (e.g. FLORA pixlar)
NEO_KHZ800 800 KHz bitstream (t.ex. hög densitet LED strip)
#define NUM_PIXELS 4
Adafruit_NeoPixel strip =
Adafruit_NeoPixel (NUM_PIXELS, 6, NEO_GRB + NEO_KHZ800);
Adafruit_TCS34725 color_sensor =
Adafruit_TCS34725 (TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
Adafruit_LSM303 accel;
#define STILL_LIGHT / / ange om ljuset är att vara på när ingen rörelse.
Annars mörka
våra RGB -> öga erkända gamma färg
byte gammatable [256];
int g_red, g_green, g_blue; globala färger Läs av färgsensor
int j;
bråka med detta nummer för att justera TWINklitude :)
lägre antal = mer känslig
#define MOVE_THRESHOLD 45
#define FADE_RATE 5
int ledde = 7.
dubbla newVector;
void flash (int gånger)
{
för (int jag = 0; jag < gånger; i ++)
{
digitalWrite (ledde, högt); Aktivera LED (HIGH är spänningsnivån)
Delay(150); vänta en sekund
digitalWrite (ledde, låg); Inaktivera LED genom att spänningen låg
Delay(150);
}
}
float r, g, b;
dubbla storedVector;
void setup()
{
pinMode ledde (, OUTPUT);
Försök att initiera och varna om vi inte kunde identifiera chip
om (! accel.begin())
{
Serial.println ("Oops... kunde inte initiera en LSM303. Kontrollera ditt ledningar!");
samtidigt (1)
{
Flash(4);
Delay(1000);
};
}
Strip.BEGIN();
Strip.show(); Initiera alla pixlar till "off"
om (! color_sensor.begin())
{
Serial.println ("No TCS34725 hittade... Kontrollera anslutningarna");
samtidigt (1)
{
Flash(3);
Delay(1000);
};
}
Tack PhilB för gamma tabellen!
Det hjälper att konvertera RGB-färger till vad människor ser
för (int jag = 0; jag < 256; i ++) {
float x = i.
x = 255;
x = pow (x, 2.5).
x * = 255;
gammatable [i] = x;
}
denna sekvens blinkar den första pixeln tre gånger
som en nedräkning till färg läsning.
för (int jag = 0; jag < 3; i ++)
{
vit, men dimmer--255 för alla tre värden gör det bländande!
strip.setPixelColor (0, strip. Färg (188, 188, 188));
Strip.show();
Delay(1000);
strip.setPixelColor (0, strip. Färg (0, 0, 0));
Strip.show();
Delay(500);
}
uint16_t klar, röd, grön, blå;
color_sensor.setInterrupt(false); slå på LED
Delay(60); tar 50 ms att läsa
color_sensor.getRawData (& röd, & green, och blå, och klart);
color_sensor.setInterrupt(true); stänga av LED
Räkna ut vissa grundläggande hex koden för visualisering
uint32_t summan = röd;
summa += grönt;
summa += blå;
summa = klart;
r = röd; r = summa;
g = grön, g = summa;
b = blå; b = summan;
r * = 256; g * = 256; b * = 256;
g_red = gammatable [(int) r];
g_green = gammatable [(int) g];
g_blue = gammatable [(int) b];
Få 3 axel vektor storlek (längd)
http://en.wikipedia.org/wiki/Euclidean_vector#length
Accel.Read();
storedVector = accel.accelData.x*accel.accelData.x;
storedVector += accel.accelData.y*accel.accelData.y;
storedVector += accel.accelData.z*accel.accelData.z;
storedVector = sqrt(storedVector);
}
void loop()
{
få nya data
Accel.Read();
Double newVector = accel.accelData.x*accel.accelData.x;
newVector += accel.accelData.y*accel.accelData.y;
newVector += accel.accelData.z*accel.accelData.z;
newVector = sqrt(newVector);
Vi ska flytta
om (abs (newVector - storedVector) > MOVE_THRESHOLD)
{
colorWipe (remsa. Color(0, 0, 0), 0);
flashRandom (10, 25); första numret är "vänta" försening,
kortare num == kortare twinkle
andra siffran är hur många neopixels till
samtidigt tänds
}
#ifdef STILL_LIGHT
annat
{
colorWipe (remsa. Färg (gammatable [(int) r],
gammatable [(int) g], gammatable[(int)b]), 0);
storedVector = newVector;
}
#endif
}
void flashRandom (int vänta, uint8_t howmany)
{
för (uint16_t jag = 0; jag < howmany; i ++)
{
för (int simul_pixels = 0; simul_pixels < 8; simul_pixels ++)
{
få en slumpmässig pixel från listan
j = random(strip.numPixels());
strip.setPixelColor (j, strip. Färg (g_red, g_green, g_blue));
}
Strip.show();
Delay(Wait);
colorWipe (remsa. Color(0, 0, 0), 0);
nu kommer att vi "tona" det i FADE_RATE steg
för (int x = 0; x < FADE_RATE; x ++)
{
int r = g_red * (x + 1); r = FADE_RATE;
int g = g_green * (x + 1); g = FADE_RATE;
int b = g_blue * (x + 1); b = FADE_RATE;
strip.setPixelColor (j, strip. Färg (r, g, b));
Strip.show();
Delay(Wait);
}
& tona ut
för (int x = FADE_RATE, x > = 0, x--)
{
int r = g_red * x; r = FADE_RATE;
int g = g_green * x; g = FADE_RATE;
int b = g_blue * x; b = FADE_RATE;
strip.setPixelColor (j, strip. Färg (r, g, b));
Strip.show();
Delay(Wait);
}
}
#ifdef STILL_LIGHT
colorWipe (remsa. Färg (gammatable [(int) r], gammatable [(int) g], gammatable[(int)b]), 0);
#endif
}
Fylla prickar en efter den andra med en färg
void colorWipe (uint32_t c, uint8_t vänta) {
för (uint16_t jag = 0; jag < strip.numPixels(); i ++) {
strip.setPixelColor (i, c);
Strip.show();
Delay(Wait);
}
}