First commit!
This commit is contained in:
Ladyada
commit
f43a8086e1
|
|
@ -0,0 +1,185 @@
|
|||
// Arduino "bridge" code between host computer and WS2801-based digital
|
||||
// RGB LED pixels (e.g. Adafruit product ID #322). Intended for use
|
||||
// with USB-native boards such as Teensy or Adafruit 32u4 Breakout;
|
||||
// works on normal serial Arduinos, but throughput is severely limited.
|
||||
// LED data is streamed, not buffered, making this suitable for larger
|
||||
// installations (e.g. video wall, etc.) than could otherwise be held
|
||||
// in the Arduino's limited RAM.
|
||||
|
||||
// Some effort is put into avoiding buffer underruns (where the output
|
||||
// side becomes starved of data). The WS2801 latch protocol, being
|
||||
// delay-based, could be inadvertently triggered if the USB bus or CPU
|
||||
// is swamped with other tasks. This code buffers incoming serial data
|
||||
// and introduces intentional pauses if there's a threat of the buffer
|
||||
// draining prematurely. The cost of this complexity is somewhat
|
||||
// reduced throughput, the gain is that most visual glitches are
|
||||
// avoided (though ultimately a function of the load on the USB bus and
|
||||
// host CPU, and out of our control).
|
||||
|
||||
// LED data and clock lines are connected to the Arduino's SPI output.
|
||||
// On traditional Arduino boards, SPI data out is digital pin 11 and
|
||||
// clock is digital pin 13. On both Teensy and the 32u4 Breakout,
|
||||
// data out is pin B2, clock is B1. LEDs should be externally
|
||||
// powered -- trying to run any more than just a few off the Arduino's
|
||||
// 5V line is generally a Bad Idea. LED ground should also be
|
||||
// connected to Arduino ground.
|
||||
|
||||
#include <SPI.h>
|
||||
|
||||
// LED pin for Adafruit 32u4 Breakout Board:
|
||||
//#define LED_DDR DDRE
|
||||
//#define LED_PORT PORTE
|
||||
//#define LED_PIN _BV(PORTE6)
|
||||
// LED pin for Teensy:
|
||||
//#define LED_DDR DDRD
|
||||
//#define LED_PORT PORTD
|
||||
//#define LED_PIN _BV(PORTD6)
|
||||
// LED pin for Arduino:
|
||||
#define LED_DDR DDRB
|
||||
#define LED_PORT PORTB
|
||||
#define LED_PIN _BV(PORTB5)
|
||||
|
||||
// A 'magic word' (along with LED count & checksum) precedes each block
|
||||
// of LED data; this assists the microcontroller in syncing up with the
|
||||
// host-side software and properly issuing the latch (host I/O is
|
||||
// likely buffered, making usleep() unreliable for latch). You may see
|
||||
// an initial glitchy frame or two until the two come into alignment.
|
||||
// The magic word can be whatever sequence you like, but each character
|
||||
// should be unique, and frequent pixel values like 0 and 255 are
|
||||
// avoided -- fewer false positives. The host software will need to
|
||||
// generate a compatible header: immediately following the magic word
|
||||
// are three bytes: a 16-bit count of the number of LEDs (high byte
|
||||
// first) followed by a simple checksum value (high byte XOR low byte
|
||||
// XOR 0x55). LED data follows, 3 bytes per LED, in order R, G, B,
|
||||
// where 0 = off and 255 = max brightness.
|
||||
|
||||
static const uint8_t magic[] = {'A','d','a'};
|
||||
#define MAGICSIZE sizeof(magic)
|
||||
#define HEADERSIZE (MAGICSIZE + 3)
|
||||
|
||||
#define MODE_HEADER 0
|
||||
#define MODE_HOLD 1
|
||||
#define MODE_DATA 2
|
||||
|
||||
void setup()
|
||||
{
|
||||
// Dirty trick: the circular buffer for serial data is 256 bytes,
|
||||
// and the "in" and "out" indices are unsigned 8-bit types -- this
|
||||
// much simplifies the cases where in/out need to "wrap around" the
|
||||
// beginning/end of the buffer. Otherwise there'd be a ton of bit-
|
||||
// masking and/or conditional code every time one of these indices
|
||||
// needs to change, slowing things down tremendously.
|
||||
uint8_t
|
||||
buffer[256],
|
||||
indexIn = 0,
|
||||
indexOut = 0,
|
||||
mode = MODE_HEADER,
|
||||
hi, lo, chk, i, spiFlag;
|
||||
int16_t
|
||||
bytesBuffered = 0,
|
||||
c;
|
||||
int32_t
|
||||
bytesRemaining;
|
||||
unsigned long
|
||||
t = 0;
|
||||
|
||||
LED_DDR |= LED_PIN; // Enable output for LED
|
||||
LED_PORT &= ~LED_PIN; // LED off
|
||||
|
||||
Serial.begin(115200); // Teensy/32u4 disregards baud rate; is OK!
|
||||
|
||||
SPI.begin();
|
||||
SPI.setBitOrder(MSBFIRST);
|
||||
SPI.setDataMode(SPI_MODE0);
|
||||
SPI.setClockDivider(SPI_CLOCK_DIV8); // 2 MHz
|
||||
// WS2801 datasheet recommends max SPI clock of 2 MHz, and 50 Ohm
|
||||
// resistors on SPI lines for impedance matching. In practice and
|
||||
// at short distances, 2 MHz seemed to work reliably enough without
|
||||
// resistors, and 4 MHz was possible with a 220 Ohm resistor on the
|
||||
// SPI clock line only. Your mileage may vary. Experiment!
|
||||
// SPI.setClockDivider(SPI_CLOCK_DIV4); // 4 MHz
|
||||
|
||||
// loop() is avoided as even that small bit of function overhead
|
||||
// has a measurable impact on this code's overall throughput.
|
||||
|
||||
for(;;) {
|
||||
|
||||
// Implementation is a simple finite-state machine.
|
||||
// Regardless of mode, check for serial input each time:
|
||||
if((bytesBuffered < 256) && ((c = Serial.read()) >= 0)) {
|
||||
buffer[indexIn++] = c;
|
||||
bytesBuffered++;
|
||||
}
|
||||
|
||||
switch(mode) {
|
||||
|
||||
case MODE_HEADER:
|
||||
|
||||
// In header-seeking mode. Is there enough data to check?
|
||||
if(bytesBuffered >= HEADERSIZE) {
|
||||
// Indeed. Check for a 'magic word' match.
|
||||
for(i=0; (i<MAGICSIZE) && (buffer[indexOut++] == magic[i++]););
|
||||
if(i == MAGICSIZE) {
|
||||
// Magic word matches. Now how about the checksum?
|
||||
hi = buffer[indexOut++];
|
||||
lo = buffer[indexOut++];
|
||||
chk = buffer[indexOut++];
|
||||
if(chk == (hi ^ lo ^ 0x55)) {
|
||||
// Checksum looks valid. Get 16-bit LED count, add 1
|
||||
// (# LEDs is always > 0) and multiply by 3 for R,G,B.
|
||||
bytesRemaining = 3L * (256L * (long)hi + (long)lo + 1L);
|
||||
bytesBuffered -= 3;
|
||||
mode = MODE_HOLD; // Proceed to latch wait mode
|
||||
spiFlag = 0; // No data out yet
|
||||
} else {
|
||||
// Checksum didn't match; search resumes after magic word.
|
||||
indexOut -= 3; // Rewind
|
||||
}
|
||||
} // else no header match. Resume at first mismatched byte.
|
||||
bytesBuffered -= i;
|
||||
}
|
||||
break;
|
||||
|
||||
case MODE_HOLD:
|
||||
|
||||
// Ostensibly "waiting for the latch from the prior frame
|
||||
// to complete" mode, but may also revert to this mode when
|
||||
// underrun prevention necessitates a delay.
|
||||
|
||||
if(micros() < t) break; // Still holding; continue buffering.
|
||||
|
||||
// Latch/delay complete. Advance to data-issuing mode...
|
||||
LED_PORT &= ~LED_PIN; // LED off
|
||||
mode = MODE_DATA; // ...and fall through (no break):
|
||||
|
||||
case MODE_DATA:
|
||||
|
||||
while(spiFlag && !(SPSR & _BV(SPIF))); // Wait for prior byte
|
||||
if(bytesRemaining > 0) {
|
||||
if(bytesBuffered > 0) {
|
||||
SPDR = buffer[indexOut++]; // Issue next byte
|
||||
bytesBuffered--;
|
||||
bytesRemaining--;
|
||||
spiFlag = 1;
|
||||
}
|
||||
// If serial buffer is threatening to underrun, start
|
||||
// introducing progressively longer pauses to allow more
|
||||
// data to arrive (up to a point).
|
||||
if((bytesBuffered < 32) && (bytesRemaining > bytesBuffered)) {
|
||||
mode = MODE_HOLD;
|
||||
t = micros() + 60 + (32 - bytesBuffered) * 20;
|
||||
}
|
||||
} else {
|
||||
// End of data -- issue latch:
|
||||
t = micros() + 1000; // Latch duration = 1000 uS
|
||||
LED_PORT |= LED_PIN; // LED on
|
||||
mode = MODE_HEADER; // Begin next header search
|
||||
}
|
||||
} // end switch
|
||||
} // end for(;;)
|
||||
}
|
||||
|
||||
void loop()
|
||||
{
|
||||
// Not used. See note in setup() function.
|
||||
}
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
EXECS = colorswirl
|
||||
|
||||
all: $(EXECS)
|
||||
|
||||
colorswirl: colorswirl.c
|
||||
cc -O2 colorswirl.c -lm -o colorswirl
|
||||
|
||||
clean:
|
||||
rm -f $(EXECS) *.o
|
||||
|
|
@ -0,0 +1,163 @@
|
|||
/*
|
||||
"Colorswirl" LED demo. This is the host PC-side code written in C;
|
||||
intended for use with a USB-connected Arduino microcontroller running the
|
||||
accompanying LED streaming code. Requires one strand of Digital RGB LED
|
||||
Pixels (Adafruit product ID #322, specifically the newer WS2801-based type,
|
||||
strand of 25) and a 5 Volt power supply (such as Adafruit #276). You may
|
||||
need to adapt the code and the hardware arrangement for your specific
|
||||
configuration.
|
||||
|
||||
This is a command-line program. It expects a single parameter, which is
|
||||
the serial port device name, e.g.:
|
||||
|
||||
./colorswirl /dev/tty.usbserial-A60049KO
|
||||
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <termios.h>
|
||||
#include <time.h>
|
||||
#include <math.h>
|
||||
|
||||
#define N_LEDS 25 // Max of 65536
|
||||
|
||||
int main(int argc,char *argv[])
|
||||
{
|
||||
int fd, i, bytesToGo, bytesSent, totalBytesSent = 0,
|
||||
frame = 0, hue1, hue2, brightness;
|
||||
unsigned char buffer[6 + (N_LEDS * 3)], // Header + 3 bytes per LED
|
||||
lo, r, g, b;
|
||||
double sine1, sine2;
|
||||
time_t t, start, prev;
|
||||
struct termios tty;
|
||||
|
||||
if(argc < 2) {
|
||||
(void)printf("Usage: %s device\n", argv[0]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if((fd = open(argv[1],O_RDWR | O_NOCTTY | O_NONBLOCK)) < 0) {
|
||||
(void)printf("Can't open device '%s'.\n", argv[1]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Serial port config swiped from RXTX library (rxtx.qbang.org):
|
||||
tcgetattr(fd, &tty);
|
||||
tty.c_iflag = INPCK;
|
||||
tty.c_lflag = 0;
|
||||
tty.c_oflag = 0;
|
||||
tty.c_cflag = CREAD | CS8 | CLOCAL;
|
||||
tty.c_cc[ VMIN ] = 0;
|
||||
tty.c_cc[ VTIME ] = 0;
|
||||
cfsetispeed(&tty, B115200);
|
||||
cfsetospeed(&tty, B115200);
|
||||
tcsetattr(fd, TCSANOW, &tty);
|
||||
|
||||
bzero(buffer, sizeof(buffer)); // Clear LED buffer
|
||||
|
||||
// Header only needs to be initialized once, not
|
||||
// inside rendering loop -- number of LEDs is constant:
|
||||
buffer[0] = 'A'; // Magic word
|
||||
buffer[1] = 'd';
|
||||
buffer[2] = 'a';
|
||||
buffer[3] = (N_LEDS - 1) >> 8; // LED count high byte
|
||||
buffer[4] = (N_LEDS - 1) & 0xff; // LED count low byte
|
||||
buffer[5] = buffer[3] ^ buffer[4] ^ 0x55; // Checksum
|
||||
|
||||
sine1 = 0.0;
|
||||
hue1 = 0;
|
||||
prev = start = time(NULL); // For bandwidth statistics
|
||||
|
||||
for(;;) {
|
||||
sine2 = sine1;
|
||||
hue2 = hue1;
|
||||
|
||||
// Start at position 6, after the LED header/magic word
|
||||
for(i = 6; i < sizeof(buffer); ) {
|
||||
// Fixed-point hue-to-RGB conversion. 'hue2' is an
|
||||
// integer in the range of 0 to 1535, where 0 = red,
|
||||
// 256 = yellow, 512 = green, etc. The high byte
|
||||
// (0-5) corresponds to the sextant within the color
|
||||
// wheel, while the low byte (0-255) is the
|
||||
// fractional part between primary/secondary colors.
|
||||
lo = hue2 & 255;
|
||||
switch((hue2 >> 8) % 6) {
|
||||
case 0:
|
||||
r = 255;
|
||||
g = lo;
|
||||
b = 0;
|
||||
break;
|
||||
case 1:
|
||||
r = 255 - lo;
|
||||
g = 255;
|
||||
b = 0;
|
||||
break;
|
||||
case 2:
|
||||
r = 0;
|
||||
g = 255;
|
||||
b = lo;
|
||||
break;
|
||||
case 3:
|
||||
r = 0;
|
||||
g = 255 - lo;
|
||||
b = 255;
|
||||
break;
|
||||
case 4:
|
||||
r = lo;
|
||||
g = 0;
|
||||
b = 255;
|
||||
break;
|
||||
case 5:
|
||||
r = 255;
|
||||
g = 0;
|
||||
b = 255 - lo;
|
||||
break;
|
||||
}
|
||||
|
||||
// Resulting hue is multiplied by brightness in the
|
||||
// range of 0 to 255 (0 = off, 255 = brightest).
|
||||
// Gamma corrrection (the 'pow' function here) adjusts
|
||||
// the brightness to be more perceptually linear.
|
||||
brightness = (int)(pow(0.5+sin(sine2)*0.5,3.0)*255.0);
|
||||
buffer[i++] = (r * brightness) / 255;
|
||||
buffer[i++] = (g * brightness) / 255;
|
||||
buffer[i++] = (b * brightness) / 255;
|
||||
|
||||
// Each pixel is offset in both hue and brightness
|
||||
hue2 += 40;
|
||||
sine2 += 0.3;
|
||||
}
|
||||
|
||||
// Slowly rotate hue and brightness in opposite directions
|
||||
hue1 = (hue1 + 5) % 1536;
|
||||
sine1 -= .03;
|
||||
|
||||
// Issue color data to LEDs. Each OS is fussy in different
|
||||
// ways about serial output. This arrangement of drain-and-
|
||||
// write-loop seems to be the most relable across platforms:
|
||||
tcdrain(fd);
|
||||
for(bytesSent=0, bytesToGo=sizeof(buffer); bytesToGo > 0;) {
|
||||
if((i=write(fd,&buffer[bytesSent],bytesToGo)) > 0) {
|
||||
bytesToGo -= i;
|
||||
bytesSent += i;
|
||||
}
|
||||
}
|
||||
// Keep track of byte and frame counts for statistics
|
||||
totalBytesSent += sizeof(buffer);
|
||||
frame++;
|
||||
|
||||
// Update statistics once per second
|
||||
if((t = time(NULL)) != prev) {
|
||||
(void)printf(
|
||||
"Average frames/sec: %d, bytes/sec: %d\n",
|
||||
(int)((float)frame / (float)(t - start)),
|
||||
(int)((float)totalBytesSent / (float)(t - start)));
|
||||
prev = t;
|
||||
}
|
||||
}
|
||||
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
// "Adalight" is a do-it-yourself facsimile of the Philips Ambilight concept
|
||||
// for desktop computers and home theater PCs. This is the host PC-side code
|
||||
// written in Processing; intended for use with a USB-connected Arduino
|
||||
// microcontroller running the accompanying LED streaming code. Requires one
|
||||
// strand of Digital RGB LED Pixels (Adafruit product ID #322, specifically
|
||||
// the newer WS2801-based type, strand of 25) and a 5 Volt power supply (such
|
||||
// as Adafruit #276). You may need to adapt the code and the hardware
|
||||
// arrangement for your specific display configuration.
|
||||
// Screen capture adapted from code by Cedrik Kiefer (processing.org forum)
|
||||
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
import processing.serial.*;
|
||||
|
||||
// This array contains the 2D image coordinates corresponding to each pixel
|
||||
// in the LED strand, which forms a ring around the perimeter of the screen
|
||||
// (with a one pixel gap at the bottom to accommodate the monitor stand).
|
||||
|
||||
static final int coord[][] = new int[][] {
|
||||
{3,5}, {2,5}, {1,5}, {0,5}, // Bottom edge, left half
|
||||
{0,4}, {0,3}, {0,2}, {0,1}, // Left edge
|
||||
{0,0}, {1,0}, {2,0}, {3,0}, {4,0}, {5,0}, {6,0}, {7,0}, {8,0}, // Top edge
|
||||
{8,1}, {8,2}, {8,3}, {8,4}, // Right edge
|
||||
{8,5}, {7,5}, {6,5}, {5,5} // Bottom edge, right half
|
||||
};
|
||||
|
||||
static final int arrayWidth = 9, // Width of Adalight array, in LED pixels
|
||||
arrayHeight = 6, // Height of Adalight array, in LED pixels
|
||||
imgScale = 20, // Size of displayed preview
|
||||
samples = 20, // Samples (per axis) when down-scaling
|
||||
s2 = samples * samples;
|
||||
|
||||
byte[] buffer = new byte[6 + coord.length * 3];
|
||||
byte[][] gamma = new byte[256][3];
|
||||
GraphicsDevice[] gs;
|
||||
PImage preview = createImage(arrayWidth, arrayHeight, RGB);
|
||||
Rectangle bounds;
|
||||
Serial port;
|
||||
|
||||
void setup() {
|
||||
GraphicsEnvironment ge;
|
||||
DisplayMode mode;
|
||||
int i;
|
||||
float f;
|
||||
|
||||
port = new Serial(this, Serial.list()[0], 115200);
|
||||
|
||||
size(arrayWidth * imgScale, arrayHeight * imgScale, JAVA2D);
|
||||
|
||||
// Initialize capture code for full screen dimensions:
|
||||
ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
|
||||
gs = ge.getScreenDevices();
|
||||
mode = gs[0].getDisplayMode();
|
||||
bounds = new Rectangle(0, 0, screen.width, screen.height);
|
||||
|
||||
// A special header / magic word is expected by the corresponding LED
|
||||
// streaming code running on the Arduino. This only needs to be initialized
|
||||
// once (not in draw() loop) because the number of LEDs remains constant:
|
||||
buffer[0] = 'A'; // Magic word
|
||||
buffer[1] = 'd';
|
||||
buffer[2] = 'a';
|
||||
buffer[3] = byte((coord.length - 1) >> 8); // LED count high byte
|
||||
buffer[4] = byte((coord.length - 1) & 0xff); // LED count low byte
|
||||
buffer[5] = byte(buffer[3] ^ buffer[4] ^ 0x55); // Checksum
|
||||
|
||||
// Pre-compute gamma correction table for LED brightness levels:
|
||||
for(i = 0; i < 256; i++) {
|
||||
f = pow(float(i) / 255.0, 2.8);
|
||||
gamma[i][0] = byte(f * 255.0);
|
||||
gamma[i][1] = byte(f * 240.0);
|
||||
gamma[i][2] = byte(f * 220.0);
|
||||
}
|
||||
}
|
||||
|
||||
void draw () {
|
||||
BufferedImage desktop;
|
||||
PImage screenShot;
|
||||
int i, j, c;
|
||||
|
||||
// Capture screen
|
||||
try {
|
||||
desktop = new Robot(gs[0]).createScreenCapture(bounds);
|
||||
}
|
||||
catch(AWTException e) {
|
||||
System.err.println("Screen capture failed.");
|
||||
return;
|
||||
}
|
||||
screenShot = new PImage(desktop); // Convert Image to PImage
|
||||
screenShot.loadPixels(); // Make pixel array readable
|
||||
|
||||
// Downsample blocks of interest into LED output buffer:
|
||||
preview.loadPixels(); // Also display in preview image
|
||||
j = 6; // Data follows LED header / magic word
|
||||
for(i = 0; i < coord.length; i++) { // For each LED...
|
||||
c = block(screenShot, coord[i][0], coord[i][1]);
|
||||
buffer[j++] = gamma[(c >> 16) & 0xff][0];
|
||||
buffer[j++] = gamma[(c >> 8) & 0xff][1];
|
||||
buffer[j++] = gamma[ c & 0xff][2];
|
||||
preview.pixels[coord[i][1] * arrayWidth + coord[i][0]] = c;
|
||||
}
|
||||
preview.updatePixels();
|
||||
|
||||
// Show preview image
|
||||
scale(imgScale);
|
||||
image(preview,0,0);
|
||||
println(frameRate);
|
||||
|
||||
port.write(buffer);
|
||||
}
|
||||
|
||||
// This method computes a single pixel value filtered down from a rectangular
|
||||
// section of the screen. While it would seem tempting to use the native
|
||||
// image scaling in Processing, in practice this didn't look very good -- the
|
||||
// extreme downsampling, coupled with the native interpolation mode, results
|
||||
// in excessive scintillation with video content. An alternate approach
|
||||
// using the Java AWT AreaAveragingScaleFilter filter produces wonderfully
|
||||
// smooth results, but is too slow for filtering full-screen video. So
|
||||
// instead, a "manual" downsampling method is used here. In the interest of
|
||||
// speed, it doesn't actually sample every pixel within a block, just a 20x20
|
||||
// grid...the results still look reasonably smooth and are handled quickly
|
||||
// enough for video. Scaling the full screen image also wastes a lot of
|
||||
// cycles on center pixels that are never used for the LED output; this
|
||||
// method gets called only for perimeter pixels. Even then, you may want to
|
||||
// set your monitor for a lower resolution before running this sketch.
|
||||
|
||||
color block(PImage image, int x, int y) {
|
||||
int c, r, g, b, row, col, rowOffset;
|
||||
float startX, curX, curY, incX, incY;
|
||||
|
||||
startX = float(screen.width / arrayWidth ) *
|
||||
(float(x) + (0.5 / float(samples)));
|
||||
curY = float(screen.height / arrayHeight) *
|
||||
(float(y) + (0.5 / float(samples)));
|
||||
incX = float(screen.width / arrayWidth ) / float(samples);
|
||||
incY = float(screen.height / arrayHeight) / float(samples);
|
||||
|
||||
r = g = b = 0;
|
||||
for(row = 0; row < samples; row++) {
|
||||
rowOffset = int(curY) * screen.width;
|
||||
curX = startX;
|
||||
for(col = 0; col < samples; col++) {
|
||||
c = image.pixels[rowOffset + int(curX)];
|
||||
r += (c >> 16) & 0xff;
|
||||
g += (c >> 8) & 0xff;
|
||||
b += c & 0xff;
|
||||
curX += incX;
|
||||
}
|
||||
curY += incY;
|
||||
}
|
||||
|
||||
return color(r / s2, g / s2, b / s2);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,123 @@
|
|||
// "Colorswirl" LED demo. This is the host PC-side code written in
|
||||
// Processing; intended for use with a USB-connected Arduino microcontroller
|
||||
// running the accompanying LED streaming code. Requires one strand of
|
||||
// Digital RGB LED Pixels (Adafruit product ID #322, specifically the newer
|
||||
// WS2801-based type, strand of 25) and a 5 Volt power supply (such as
|
||||
// Adafruit #276). You may need to adapt the code and the hardware
|
||||
// arrangement for your specific configuration.
|
||||
|
||||
import processing.serial.*;
|
||||
|
||||
int N_LEDS = 25; // Max of 65536
|
||||
|
||||
void setup()
|
||||
{
|
||||
byte[] buffer = new byte[6 + N_LEDS * 3];
|
||||
Serial myPort;
|
||||
int i, hue1, hue2, bright, lo, r, g, b, t, prev, frame = 0;
|
||||
long totalBytesSent = 0;
|
||||
float sine1, sine2;
|
||||
|
||||
noLoop();
|
||||
|
||||
// Assumes the Arduino is the first/only serial device. If this is not the
|
||||
// case, change the device index here. println(Serial.list()); can be used
|
||||
// to get a list of available serial devices.
|
||||
myPort = new Serial(this, Serial.list()[0], 115200);
|
||||
|
||||
// A special header / magic word is expected by the corresponding LED
|
||||
// streaming code running on the Arduino. This only needs to be initialized
|
||||
// once because the number of LEDs remains constant:
|
||||
buffer[0] = 'A'; // Magic word
|
||||
buffer[1] = 'd';
|
||||
buffer[2] = 'a';
|
||||
buffer[3] = byte((N_LEDS - 1) >> 8); // LED count high byte
|
||||
buffer[4] = byte((N_LEDS - 1) & 0xff); // LED count low byte
|
||||
buffer[5] = byte(buffer[3] ^ buffer[4] ^ 0x55); // Checksum
|
||||
|
||||
sine1 = 0.0;
|
||||
hue1 = 0;
|
||||
prev = second(); // For bandwidth statistics
|
||||
|
||||
for (;;) {
|
||||
sine2 = sine1;
|
||||
hue2 = hue1;
|
||||
|
||||
// Start at position 6, after the LED header/magic word
|
||||
for (i = 6; i < buffer.length; ) {
|
||||
// Fixed-point hue-to-RGB conversion. 'hue2' is an integer in the
|
||||
// range of 0 to 1535, where 0 = red, 256 = yellow, 512 = green, etc.
|
||||
// The high byte (0-5) corresponds to the sextant within the color
|
||||
// wheel, while the low byte (0-255) is the fractional part between
|
||||
// the primary/secondary colors.
|
||||
lo = hue2 & 255;
|
||||
switch((hue2 >> 8) % 6) {
|
||||
case 0:
|
||||
r = 255;
|
||||
g = lo;
|
||||
b = 0;
|
||||
break;
|
||||
case 1:
|
||||
r = 255 - lo;
|
||||
g = 255;
|
||||
b = 0;
|
||||
break;
|
||||
case 2:
|
||||
r = 0;
|
||||
g = 255;
|
||||
b = lo;
|
||||
break;
|
||||
case 3:
|
||||
r = 0;
|
||||
g = 255 - lo;
|
||||
b = 255;
|
||||
break;
|
||||
case 4:
|
||||
r = lo;
|
||||
g = 0;
|
||||
b = 255;
|
||||
break;
|
||||
default:
|
||||
r = 255;
|
||||
g = 0;
|
||||
b = 255 - lo;
|
||||
break;
|
||||
}
|
||||
|
||||
// Resulting hue is multiplied by brightness in the range of 0 to 255
|
||||
// (0 = off, 255 = brightest). Gamma corrrection (the 'pow' function
|
||||
// here) adjusts the brightness to be more perceptually linear.
|
||||
bright = int(pow(0.5 + sin(sine2) * 0.5, 2.8) * 255.0);
|
||||
buffer[i++] = byte((r * bright) / 255);
|
||||
buffer[i++] = byte((g * bright) / 255);
|
||||
buffer[i++] = byte((b * bright) / 255);
|
||||
|
||||
// Each pixel is slightly offset in both hue and brightness
|
||||
hue2 += 40;
|
||||
sine2 += 0.3;
|
||||
}
|
||||
|
||||
// Slowly rotate hue and brightness in opposite directions
|
||||
hue1 = (hue1 + 4) % 1536;
|
||||
sine1 -= .03;
|
||||
|
||||
// Issue color data to LEDs and keep track of the byte and frame counts
|
||||
myPort.write(buffer);
|
||||
totalBytesSent += buffer.length;
|
||||
frame++;
|
||||
|
||||
// Update statistics once per second
|
||||
if ((t = second()) != prev) {
|
||||
print("Average frames/sec: ");
|
||||
print(int((float)frame / (float)millis() * 1000.0));
|
||||
print(", bytes/sec: ");
|
||||
println(int((float)totalBytesSent / (float)millis() * 1000.0));
|
||||
prev = t;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void draw()
|
||||
{
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue