Etape 1: Le Code
J’ai expérimenté avec des sections plus, mais pas plus que 10 causé trop d’utilisation de l’UC.
Peu de temps après, j’ai décidé de mettre en œuvre TouchOSC dans le programme pour permettre un contrôle iPhone. Ce code n’est pas inclus dans ce instructable, cependant si vous écrivez-moi (cgmalantonio je vous enverrai volontiers le code. Ce code permet une bascule sur les lumières ambiantes, ainsi que les curseurs RGB et un pavé tactile XY pour générer encore plus de couleurs.
Eh bien, permet de commencer !
Tout d’abord, nous avons le code Arduino, celui-ci est compétent pour prendre les valeurs RVB de l’esquisse de traitement et la sortie de ces valeurs à la bande de NeoPixel.
--------------------------------------------------------------------------------------------
--------------------------------Arduino Sketch----------------------------------------
--------------------------------------------------------------------------------------------
Ambi : AmbientNeoPixel Arduino Sketch
Créé par : Cory Malantonio
#include < Adafruit_NeoPixel.h >
#define PIN 6
Bande de Adafruit_NeoPixel = Adafruit_NeoPixel (60, PIN, NEO_GRB + NEO_KHZ800) ;
int r [11] ; Tableau pour chaque valeur de couleur
int g [11] ;
int b [11] ;
void setup() {}
Serial.Begin(9600) ;
Strip.Begin() ; préparation de la neopixel
Strip.Show() ;
}
void loop() {}
Si (Serial.available() > = 31) {}
Si (Serial.read() == 0xff) {}
pour (int x = 1, x < 11, x ++) {}
r [x] = Serial.read() ; lire les valeurs de transformation
g [x] = Serial.read() ; nous les avons envoyés dans le même ordre
b [x] = Serial.read() ;
r [x] = contraindre (r [x], 0, 255) ; juste au cas où n’importe quel glissement de valeurs loin
g [x] = contraindre (g [x], 0, 255) ;
b [x] = contraindre (b [x], 0, 255) ;
}
}
}
int Xval = 1 ; compter jusqu'à 30
int Yval = 2 ; pendant le chargement des valeurs RVB
int Zval = 3 ; dans 3 led est à la fois
pour (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() ; sortie à la neopixel
Delay(20) ; pour la sécurité
}
--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
Voici l’esquisse de traitement,
la seule véritable ajustement que vous aurez à faire sera la ligne
port = nouvelle série (ce, Serial.list() [#], 9600 ;
Le # se réfère au numéro de périphérique usb, que l’arduino est bien branché.
Je suggère d’essayer les 0, puis 1, puis 2, etc jusqu'à ce que vous trouviez celui que vous utilisez.
--------------------------------------------------------------------------------------------
--------------------------------Processing Sketch-----------------------------------
--------------------------------------------------------------------------------------------
Edit : J’ai reçu un e-mail grand, poser des questions sur la modification de la résolution sur le croquis de traitement.
Depuis lors, j’ai changé l’esquisse de traitement avec un plus apte à modifier (sans avoir à plonger dans le code).
--------------------------------------------------------------------------------------------
/ * Ambi2 : AmbientNeoPixel traitement Sketch
** Créé par : Cory Malantonio
** ambiArray est basé sur une conception par Rajarshi Roy
*/
Import cc.arduino.* ;
java.awt.Robot d’importation ;
java.awt.AWTException d’importation ;
import java.awt.event.InputEvent ;
java.awt.image.BufferedImage d’importation ;
java.awt.Rectangle d’importation ;
java.awt.Dimension d’importation ;
Import processing.serial.* ;
---La valeur résolution ici---/ /
resX int = 1920 ;
int resY = 1080 ;
//-------------------------------//
int sectW = resX / 10 ; Grosseur de boudin pour les 10 sections
int SectRx = sectW / 4 ; Résolution de section pour x
int SectRy = resY / 4 ; Résolution de section pour y
Port série ;
Robot GrabRGBval ;
void setup()
{
port = nouvelle série (ce, Serial.list() [2], 9600) ;
Serial.List() [#], # = numéro de périphérique usb
Essayez
{
GrabRGBval = new Robot() ;
}
catch (AWTException e)
{
println ("Robot classe non pris en charge par votre système!") ;
Exit() ;
}
taille (200, 200) ;
Background(0) ;
noFill() ;
}
void draw()
{
int pixel ;
float [] rA = nouveau float [11] ;
float [] gA = nouveau float [11] ;
bA de float [] = new Char [11] ;
int [] reso = new int [11] ;
pour (int Ar = 1 ; AR < 11 ; AR++) {//load les résolutions dans le tableau
RESO [Ar] = sectW * Ar ; 192 est 1/10 de la résolution 1920
}
flotteur r = 0 ;
flotteur g = 0 ;
float b = 0 ;
RESO [0] = 0 ;
Capture d’écran de BufferedImage = GrabRGBval.createScreenCapture (new Rectangle (new Dimension (resX, resY))) ;
pour (int LED = 1 ; CONDUIT < 11 ; LED++) {}
int x = 0 ;
int y = 0 ;
tranches de tableau RESO au 10ème de la résolution de 1920, en commençant par 0
pour (x = reso [del-1]; x < reso [LED]; x = x + 4) {//"x + 4" saute pixels
pour (y = 0; y < resY; y = y + 4) {/ / pour l’aider à courir plus vite
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 est 1/4ème chaque 10ème de l’écran. Avant nous sommes sauter pixels
g=g/(SectRx*SectRy) ; Nous nous retrouvons avec 1/4 les pixels.
b=b/(SectRx*SectRy) ; 270 est 1/4 de la résolution 1080
rA [LED] = r ;
gA [LED] = g ;
bA [LED] = b ;
}
port.Write(0xFF) ; écrire le marqueur, arduino est la recherche de ce
pour (int Br = 1 ; BR < 11 ; BR++) {}
port.Write((Byte)(RA[br])) ;
port.Write((Byte)(GA[br])) ;
port.Write((Byte)(BA[br])) ;
}
Delay(10) ; délai pour la sécurité
pour (int cône = 1; cône < 11 ; cône ++) {}
Fill(0) ;
accident vasculaire cérébral (rA [conique], gA [conique], bA[cOne]) ;
Rect ((cOne-1) * 20, 0, cône * 20, 200) ;
remplissage (rA [conique], gA [conique], bA[cOne]) ;
Rect ((cOne-1) * 20, 0, cône * 20, 200) ;
}
}
