#include <FastLED.h>

#define NUM_LEDS  32
#define DATA_PIN 11
#define CLOCK_PIN 13
#define SPEED 115200

const int eingang1 = 2;
const int eingang2 = 3;
const int eingang3 = 4;
int wert1  = 0;
int wert2  = 0;
int wert3  = 0;


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

static const uint8_t magic[] = {'A', 'd', 'a'};
#define MAGICSIZE  sizeof(magic)
#define HEADERSIZE (MAGICSIZE + 3)

#define MODE_HEADER 0
#define MODE_DATA   2

static const unsigned long serialTimeout = 150000; // 150 seconds



void setup() {
  FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, BGR>(leds, NUM_LEDS);
  pinMode(eingang1, INPUT_PULLUP);
  pinMode(eingang2, INPUT_PULLUP);
  pinMode(eingang3, INPUT_PULLUP);



}

void loop() {
  wert1 = digitalRead(eingang1);
  wert2 = digitalRead(eingang2);
  wert3 = digitalRead(eingang3);

  if (wert1 == LOW) {
    //vollweiss
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CHSV(255 , 0, 255);
    }
    FastLED.show();
  }
  if (wert2 == LOW) {
    //halbweiss
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CHSV(155 , 0, 155);
    }
    FastLED.show();
  }
  if (wert3 == LOW) {


    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(;;)
  }
}