// 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 //Jeg har leget lidt med noget knap til at kunne få lyset til at følge lyde eller beats fra musikken. Dette er dog ikke en del af projektet, men bare noget jeg har rodet lidt med. //derfor er det en del af koden et par steder. //Alt koden der har en indrykning der skiller sig væsentligt ud fra det andet, er kode jeg har tilføjet. Som f.eks. det der er indrykket neden under. Koden udover er lånt fra nettet. #include "FastLED.h" #define NUM_LEDS 180 // Max LED count #define LED_PIN 6 // arduino output pin #define GROUND_PIN 10 #define SPEED 115200 // virtual serial port speed, must be the same in boblight_config int Led = 13 ;// define LED Interface int buttonpin = 3; // define D0 Sensor Interface int val = 0; // define numeric variables val int knap = 10 ; 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 #define MAX_LYSSTYRKE 255// Max styrke på LED #define MIN_LYSSTYRKE 0// Minimum styke på LED const int lysstyrkeInPin = A0;// Analogudgangen som styrer lysstyrken på LED'ene, her er potentiometeret tilsluttet #include // DHT bibliotek, hvor der er funktioner til temperatur sensoren DHT11 dht DHT; #define DHT11_PIN 7 void setup() { pinMode(GROUND_PIN, OUTPUT); digitalWrite(GROUND_PIN, LOW); FastLED.addLeds(leds, NUM_LEDS); FastLED.setBrightness(MAX_LYSSTYRKE); int mappedValue = map(analogRead(lysstyrkeInPin), 0, 1023, 0, 255); FastLED.setBrightness(constrain(mappedValue, MIN_LYSSTYRKE, MAX_LYSSTYRKE)); int mappedHue; pinMode (Led, OUTPUT) ; // definer LED som output til test med pære pinMode (buttonpin, INPUT) ; // output interface D0 is defined sensor pinMode (knap, INPUT); //definer knap, som skal styrer om Lyd detekter modulet må aktivere led'ene med rødt lys alt efter om der er lyd eller ej, det skal følge musikkens beat Serial.begin(115200); //Fjern // for at tjekke temperatur // 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 (;;) { val = digitalRead(buttonpin); // digital interface will be assigned a value of pin 3 to read val if (digitalRead(knap) && (val==HIGH)) // Hvis vores knap er aktiveret og lyd sensoren får højt input, så må vi tænde for LED'ene med rød farve { fill_solid(leds, NUM_LEDS, CRGB::Red); FastLED.show(); } if (digitalRead(knap) && (val==LOW)) { fill_solid(leds, NUM_LEDS, CRGB::Black); FastLED.show(); } if (DHT.temperature >=30) // Sikkerhed for at LED ikke bliver over X antal grader varm og brænder af. { fill_solid(leds, NUM_LEDS, CRGB::Black); FastLED.show(); } //Fjern // for at tjekke temperatur på DTH11 sensoren og husk at vælg 115200 band rate // int chk = DHT.read11(DHT11_PIN); // Serial.print("Temperature = "); // Serial.println(DHT.temperature); // Serial.print("Humidity = "); // Serial.println(DHT.humidity); // delay(1000); // 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(); int mappedValue = map(analogRead(lysstyrkeInPin), 0, 1023, 0, 255); FastLED.setBrightness(constrain(mappedValue, MIN_LYSSTYRKE, MAX_LYSSTYRKE)); int mappedHue; // Her bruges dette til at sætte lysstyken på LED lysene. } } // end switch } // end for(;;) } void loop() { // Not used. See note in setup() function. }