Adalight-FastLED_rgbwMod/Arduino/LEDstream_FastLED/LEDstream_FastLED.ino

/* LEDstream_FastLED
 * 
 * Modified version of Adalight protocol that uses the FastLED
 * library (http://fastled.io) for driving led strips.
 * 
 * http://github.com/dmadison/Adalight-FastLED
 * Last Updated: 2017-04-08
 */

// --- General Settings
static const uint8_t 
	Num_Leds   =  80,        // strip length
	Led_Pin    =  6,         // Arduino data output pin
	Brightness =  255;       // maximum brightness

// --- FastLED Setings
#define LED_TYPE     WS2812B // led strip type for FastLED
#define COLOR_ORDER  GRB     // color order for bitbang

// --- Serial Settings
static const unsigned long
	SerialSpeed    = 115200, // serial port speed, max available
	SerialTimeout  = 150000; // time before LEDs are shut off, if no data
							 // (150 seconds)

// --- Optional Settings (uncomment to add)
//#define CLEAR_ON_START     // LEDs are cleared on reset
//#define GROUND_PIN 10      // additional grounding pin (optional)
//#define CALIBRATE          // sets all LEDs to the color of the first
//#define DEBUG_LED 13       // turns on the Arduino's built-in LED
                             //   if the magic word + checksum match

// --------------------------------------------------------------------

#include <FastLED.h>

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)

// Check values are header byte # - 1, as they are indexed from 0
#define HICHECK    (MAGICSIZE)
#define LOCHECK    (MAGICSIZE + 1)
#define CHECKSUM   (MAGICSIZE + 2)

#define MODE_HEADER 0
#define MODE_DATA   1

void setup(){
	#ifdef GROUND_PIN
		pinMode(GROUND_PIN, OUTPUT);
		digitalWrite(GROUND_PIN, LOW);
	#endif

	#ifdef DEBUG_LED
		pinMode(DEBUG_LED, OUTPUT);
		digitalWrite(DEBUG_LED, LOW);
	#endif

	FastLED.addLeds<LED_TYPE, Led_Pin, COLOR_ORDER>(leds, Num_Leds);
	FastLED.setBrightness(Brightness);

	#ifdef CLEAR_ON_START
		FastLED.show();
	#endif

	Serial.begin(SerialSpeed);

	adalight();
}

void adalight(){ 
	static uint8_t
		mode = MODE_HEADER;
	static uint8_t
		headPos,
		hi, lo, chk;
	int16_t
		c;
	static uint16_t
		outPos;
	static uint32_t
		bytesRemaining;
	unsigned long
		t;
	static unsigned long
		lastByteTime,
		lastAckTime;

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

	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((c = Serial.read()) >= 0){
			lastByteTime = lastAckTime = t; // Reset timeout counters
			
			switch(mode) {
	
			case MODE_HEADER:

				if(headPos < MAGICSIZE){
					if(c == magic[headPos]) headPos++;
					else headPos = 0;
				}
				else{
					switch(headPos){
						case HICHECK:
							hi = c;
							headPos++;
							break;
						case LOCHECK:
							lo = c;
							headPos++;
							break;
						case CHECKSUM:
							chk = c;
							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.
								#ifdef DEBUG_LED
									digitalWrite(DEBUG_LED, HIGH);
								#endif

								bytesRemaining = 3L * (256L * (long)hi + (long)lo + 1L);
								outPos = 0;
								memset(leds, 0, Num_Leds * sizeof(struct CRGB));
								mode = MODE_DATA; // Proceed to latch wait mode
							}
							headPos = 0; // Reset header position regardless of checksum result
							break;
					}
				}
				break;
	
			case MODE_DATA:

				if(bytesRemaining > 0) {
					if (outPos < sizeof(leds)){
						#ifdef CALIBRATE
							if(outPos < 3)
								ledsRaw[outPos++] = c;
							else{
								ledsRaw[outPos] = ledsRaw[outPos%3]; // Sets RGB data to first LED color
								outPos++;
							}
						#else
							ledsRaw[outPos++] = c; // Issue next byte
						#endif
					}
					bytesRemaining--;
				}
				if(bytesRemaining == 0) {
					// End of data -- issue latch:
					mode = MODE_HEADER; // Begin next header search
					FastLED.show();

					#ifdef DEBUG_LED
						digitalWrite(DEBUG_LED, LOW);
					#endif
				}
				break;
			} // end switch
		} // end serial if
		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
			}
		} // end else
	} // end for(;;)
}

void loop()
{
	// loop() is avoided as even that small bit of function overhead
	// has a measurable impact on this code's overall throughput.
}