Omgivande dator ljus - med en Arduino med NeoPixel band (1 / 1 steg)

Steg 1: Koden

Det verkliga kött och ben av detta projekt är den kod som möjliggör ljusstrålningen. För ett tag sedan hittade jag några kod av Rajarshi Roy som ägde genomsnittliga rgb-värden från en skärmdump av datorskärmen (med bearbetning) som ska användas med en rgb ledde. Jag ändrade då koden för att skanna skärmdumpen i 10 avsnitt (192 x 1080 upplösning). När jag hade det genomsnittliga värdet av varje avsnitt kunde jag sedan ut värdena till arduino, och sedan till NeoPixel band. Eftersom det finns 30 ledde är för att arbeta med, jag tilldelade 3 ledde är för att representera varje avsnitt av skärmen.

Jag experimenterade med fler sektioner, men något mer än 10 orsakat för mycket cpu-användning.

Snart efter bestämde jag mig att genomföra TouchOSC in i programmet för iPhone-kontroll. Att koden inte ingår i detta instructable, men om du maila mig (cgmalantonio skickar jag gärna dig koden. Denna kod kan för en växla på de omgivande ljus, samt RGB reglagen och en XY touch pad för att skapa ännu fler färger.

Tja, kan börja!

Först har vi Arduino koden, detta är ansvarig för att ta de rgb-värdena från den bearbetning skissen och mata dessa värden till NeoPixel band.

--------------------------------------------------------------------------------------------
--------------------------------Arduino Sketch----------------------------------------
--------------------------------------------------------------------------------------------

Ambi: AmbientNeoPixel Arduino skiss
Skapad av: Cory Malantonio

#include < Adafruit_NeoPixel.h >
#define stift 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel (60, PIN, NEO_GRB + NEO_KHZ800);

int r [11]. matris för varje färgvärde
int g [11].
int b [11].

void setup() {
Serial.BEGIN(9600);
Strip.BEGIN(); prep i neopixel
Strip.show();
}

void loop() {

om (Serial.available() > = 31) {
om (Serial.read() == 0xff) {
för (int x = 1; x < 11; x ++) {
r [x] = Serial.read(); läste i värden från bearbetning
g [x] = Serial.read(); i samma ordning skickade vi dem
b [x] = Serial.read();

r [x] = begränsa (r [x], 0, 255); bara incase någon värden glida bort
g [x] = begränsa (g [x], 0, 255);
b [x] = begränsa (b [x], 0, 255);

}
}
}

int Xval = 1; räkna till 30
int Yval = 2; vid inläsning av rgb-värden
int Zval = 3; i 3 led's i taget

för (int z = 1, z < 11, z ++) {

strip.setPixelColor (Xval, r [z], g [z], b[z]);
strip.setPixelColor (Yval, r [z], g [z], b[z]);
strip.setPixelColor (Zval, r [z], g [z], b[z]);

Xval = Xval + 3.
Yval = Yval + 3.
Zval = Zval + 3.
}

Strip.show(); utgång till neopixel
Delay(20); för säkerhet
}

--------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------

Här är den bearbetning skissen,
den enda verkliga justering måste du göra kommer att raden
Port = ny följetong (denna, Serial.list() [#], 9600;

# hänvisar till USB-enhetsnumret arduino är ansluten till.
Jag skulle föreslå att försöka 0, då 1, sedan 2, osv tills du hittar den du använder.

--------------------------------------------------------------------------------------------
--------------------------------Processing Sketch-----------------------------------
--------------------------------------------------------------------------------------------
Redigera: Jag fick en stor e-postmeddelande ber om att ändra resolutionen om bearbetning skissen.
Sedan dess har bytt jag ut bearbetning skissen med en mer lämpligt att redigera (utan att dyka in i koden).
--------------------------------------------------------------------------------------------

/ * Ambi2: AmbientNeoPixel Processing skiss
** Skapad av: Cory Malantonio
** ambiArray är baserad på en design av Rajarshi Roy
*/

import cc.arduino.*;
import java.awt.Robot;
import java.awt.AWTException;
import java.awt.event.InputEvent;
import java.awt.image.BufferedImage;
import java.awt.Rectangle;
import java.awt.Dimension;
import processing.serial.*;

---Ange upplösning här---/ /
int resX = 1920;
int resY = 1080;
//-------------------------------//

int sectW = resX / 10; Genomskärningsbredden för 10 sektioner
int SectRx = sectW / 4; Avsnittet resolution för x
int SectRy = resY / 4; Avsnittet resolution för y

Seriell port;
Robot GrabRGBval;

void setup()
{
Port = ny följetong (denna, Serial.list() [2], 9600);
Serial.list() [#], # = usb enhet nummer

försök
{
GrabRGBval = ny Robot();
}
fånga (AWTException e)
{
println ("Robot klass stöds inte av datorn!");
Exit();
}

storlek (200, 200);
Background(0);
noFill();
}

void draw()
{
int pixel.

flyta [] rA = ny float [11].
flyta [] gA = ny float [11].
float [] bA = ny float [11].
int [] reso = nya int [11].

för (int Ar = 1; Ar < 11. Ar++) {//load resolutioner i vektorn
Reso [Ar] = sectW * Ar; 192 är 1/10 av resolutionen som 1920
}

flyta r = 0;
flyta g = 0;
flyta b = 0;
Reso [0] = 0;

BufferedImage skärmdump = GrabRGBval.createScreenCapture (nya rektangel (ny Dimension (resX, resY)));

för (int LED = 1; LEDDE < 11. LED++) {
int x = 0;
int y = 0;

Reso array steg i 10ths i 1920 resolutionen, börjar på 0
för (x = reso [LED-1], x < reso [LED], x = x + 4) {//"x + 4" hopanden pixlar
för (y = 0; y < resY; y = y + 4) {/ / för att hjälpa det snabbare
pixel = screenshot.getRGB (x, y);
r = r+(int) (255 & (pixel >> 16));
g = g+(int) (255 & (pixel >> 8));
b = b+(int) (255 & (pixel));
}
}

r=r/(SectRx*SectRy); 48 är 1/4th varje 10: e i skärmen. Framför vi hopanden pixlar
g=g/(SectRx*SectRy); Vi är kvar med 1/4 pixlar.
b=b/(SectRx*SectRy); 270 är 1/4 av 1080 upplösning
rA [LED] = r;
gA [LED] = g;
bA [LED] = b;

}

port.write(0xFF); Skriv markör, arduino letar efter denna
för (int Br = 1; Br < 11. Br++) {
port.write((byte)(ra[br]));
port.write((byte)(gA[br]));
port.write((byte)(ba[br]));
}

Delay(10); fördröjning för säkerhet

för (int kon = 1; kon < 11; kon ++) {
Fill(0);
stroke (rA [kon], [kon] gA, bA[cOne]);
rekt ((cOne-1) * 20, 0, kon * 20, 200);
fyllning (rA [kon], [kon] gA, bA[cOne]);
rekt ((cOne-1) * 20, 0, kon * 20, 200);
}
}