ambilight.ino

// Slightly modified Adalight protocol implementation that uses FastLED // library (http://fastled.io) for driving WS2811/WS2812 led stripe // Was tested only with Prismatik software from Lightpack project

#include "FastLED.h"

#define NUM_LEDS 114 // Max LED count #define LED_PIN 6 // arduino output pin #define GROUND_PIN 10 #define BRIGHTNESS 255 // maximum brightness #define SPEED 115200 // virtual serial port speed, must be the same in boblight_config

CRGB leds[NUM_LEDS]; uint8_t * ledsRaw = (uint8_t *)leds;

// 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_DATA 2

// If no serial data is received for a while, the LEDs are shut off // automatically. This avoids the annoying "stuck pixel" look when // quitting LED display programs on the host computer. static const unsigned long serialTimeout = 150000; // 150 seconds

void setup() { pinMode(GROUND_PIN, OUTPUT); digitalWrite(GROUND_PIN, LOW); FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);

// 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, hold = 0, c; int32_t bytesRemaining; unsigned long startTime, lastByteTime, lastAckTime, t; int32_t outPos = 0;

Serial.begin(SPEED); // Teensy/32u4 disregards baud rate; is OK!

Serial.print("Ada\n"); // Send ACK string to host

startTime    = micros();

lastByteTime = lastAckTime = millis();

// 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:
t = millis();
if((bytesBuffered < 256) && ((c = Serial.read()) >= 0)) {
  buffer[indexIn++] = c;
  bytesBuffered++;
  lastByteTime = lastAckTime = t; // Reset timeout counters
} 
else {
  // No data received.  If this persists, send an ACK packet
  // to host once every second to alert it to our presence.
  if((t - lastAckTime) > 1000) {
    Serial.print("Ada\n"); // Send ACK string to host
    lastAckTime = t; // Reset counter
  }
  // If no data received for an extended time, turn off all LEDs.
  if((t - lastByteTime) > serialTimeout) {
    memset(leds, 0,  NUM_LEDS * sizeof(struct CRGB)); //filling Led array by zeroes
    FastLED.show();
    lastByteTime = t; // Reset counter
  }
}

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;
        outPos = 0;
        memset(leds, 0,  NUM_LEDS * sizeof(struct CRGB));
        mode           = MODE_DATA; // Proceed to latch wait mode
      } 
      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_DATA:

  if(bytesRemaining > 0) {
    if(bytesBuffered > 0) {
      if (outPos < sizeof(leds))
        ledsRaw[outPos++] = buffer[indexOut++];   // Issue next byte
      bytesBuffered--;
      bytesRemaining--;
    }
    // If serial buffer is threatening to underrun, start
    // introducing progressively longer pauses to allow more
    // data to arrive (up to a point).
  } 
  else {
    // End of data -- issue latch:
    startTime  = micros();
    mode       = MODE_HEADER; // Begin next header search
    FastLED.show();
  }
} // end switch

} // end for(;;) }

void loop() { // Not used. See note in setup() function. }