Paso 1: El código
Experimenté con más secciones, pero más de 10 demasiado uso de la cpu.
Poco después decidió implementar TouchOSC en el programa para control de iPhone. Ese código no está incluido en este instructable, sin embargo si te email me (cgmalantonio con mucho gusto te enviaremos el código. Este código permite un palanca de las luces de ambiente, así como deslizadores RGB y un teclado XY para generar colores más.
Bueno, vamos a empezar!
En primer lugar tenemos el código de Arduino, este es responsable de tomando los valores rgb del bosquejo de procesamiento y la salida de esos valores a la franja de NeoPixel.
--------------------------------------------------------------------------------------------
--------------------------------Arduino Sketch----------------------------------------
--------------------------------------------------------------------------------------------
AMBI: AmbientNeoPixel Sketch de Arduino
Creado por: Cory Malantonio
#include < Adafruit_NeoPixel.h >
#define PIN 6
Tira de Adafruit_NeoPixel = Adafruit_NeoPixel (60, PIN, NEO_GRB + NEO_KHZ800);
int r [11]; matriz para cada valor de color
int g [11];
int b [11];
void setup() {}
Serial.Begin(9600);
Strip.Begin(); preparación para el neopixel
Strip.Show();
}
void loop() {}
Si (Serial.available() > = 31) {}
Si (Serial.read() == 0xff) {}
para (int x = 1; x < 11; x ++) {}
r [x] = Serial.read(); leer los valores de proceso
g [x] = Serial.read(); en el mismo orden nos enviaron
b [x] = Serial.read();
r [x] = limitar (r [x], 0, 255); sólo en caso cualquier resbalón de valores a
g [x] = limitar (g [x], 0, 255);
b [x] = limitar (b [x], 0, 255);
}
}
}
int Xval = 1; contar hasta 30
int Yval = 2; al cargar valores rgb
int Zval = 3; 3 led's en un momento
para (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(); salida a la neopixel
Delay(20); para la seguridad
}
--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
Aquí está el bosquejo de procesamiento,
el ajuste real sólo que tendrás que hacer será la línea de
puerto = serie nueva (este, Serial.list() [#], 9600;
la # se refiere al número de dispositivo usb que está enchufado el arduino.
sugeriría probar 0 luego 1 luego 2, etc. hasta que encuentres uno que utiliza.
--------------------------------------------------------------------------------------------
--------------------------------Processing Sketch-----------------------------------
--------------------------------------------------------------------------------------------
Edit: tengo un gran email preguntando sobre cómo cambiar la resolución en el bosquejo del proceso.
Desde entonces, ha cambiado hacia fuera el esbozo de procesamiento con una más para editar (sin tener que bucear en el código).
--------------------------------------------------------------------------------------------
/ * Ambi2: AmbientNeoPixel proceso de bosquejo
** Creado por: Cory Malantonio
** ambiArray se basa en un diseño por Rajarshi Roy
*/
Import cc.arduino.*;
Import java.awt.Robot;
Import java.awt.AWTException;
Import java.awt.event.InputEvent;
java.awt.image.BufferedImage importación;
importación java.awt.Rectangle;
importación java.awt.Dimension;
Import processing.serial.*;
---Establecer resolución aquí---/ /
int resX = 1920;
resY int = 1080;
//-------------------------------//
int sectW = resX / 10; Anchura de sección para las secciones de 10
int SectRx = sectW / 4; Resolución de la sección x
int SectRy = resY / 4; Resolución de la sección y
Puerto serial;
Robot GrabRGBval;
void setup()
{
puerto = serie nueva (este, Serial.list() [2], 9600);
Serial.List() [#], # = número de dispositivo usb
tratar de
{
GrabRGBval = nueva Robot();
}
catch (AWTException e)
{
println ("Robot clase no admite el sistema!");
Exit();
}
tamaño (200, 200);
Background(0);
noFill();
}
void draw()
{
int pixel;
Float [] rA = new float [11];
Float [] gA = new float [11];
bA de Float [] = new float [11];
reso de int [] = new int [11];
para (int Ar = 1; Ar < 11; Ar++) {//load las resoluciones en la matriz
reso [Ar] = sectW * Ar; 192 es 1/10 de la resolución de 1920
}
Float r = 0;
flotador de g = 0;
Float b = 0;
reso [0] = 0;
BufferedImage imagen = GrabRGBval.createScreenCapture (nuevo rectángulo (nueva dimensión (resX, resY)));
para (int LED = 1; LED < 11; LED++) {}
int x = 0;
int y = 0;
incrementos de la matriz de reso en 10ths de la resolución de 1920, a partir de las 0
para (x = reso [LED-1]; x < reso [LED]; x = x + 4) {//"x + 4" es saltar píxeles
para (y = 0; y < resY; y = y + 4) {/ / para ayudar a correr más rápido
Pixel = screenshot.getRGB (x, y);
r = r+(int) (255 & (pixel >> 16));
g = g+(int) (255 & (pixel >> 8));
b = b+(int) (255 y (pixel));
}
}
r=r/(SectRx*SectRy); 48 es 1/4 cada 10 de la pantalla. Sobre nosotros estamos omitiendo píxeles
g=g/(SectRx*SectRy); nos quedamos con 1/4 de los píxeles.
b=b/(SectRx*SectRy); 270 es de 1/4 de la resolución 1080
rA [LED] = r;
gA [LED] = g;
bA [LED] = b;
}
Port.Write(0xFF); escribir el marcador, esto busca arduino
para (int Br = 1; Br < 11; Br++) {}
Port.Write((byte)(RA[br]));
Port.Write((byte)(GA[br]));
Port.Write((byte)(BA[br]));
}
Delay(10); retardo por seguridad
para (cono int = 1; cono < 11; cono ++) {}
Fill(0);
accidente cerebrovascular (rA [cono] gA [cono], bA[cOne]);
Rect ((cOne-1) * 20, 0, cono * 20, 200);
relleno (rA [cono] gA [cono], bA[cOne]);
Rect ((cOne-1) * 20, 0, cono * 20, 200);
}
}
