LED-Matrix (15x12) Probleme mit der Kommunikation zwischen Arduino und Jinx / Glediator

    LED-Matrix (15x12) Probleme mit der Kommunikation zwischen Arduino und Jinx / Glediator

    Morgen zusammen,
    da ich noch anfänger mit Arduino und der Programmierung bin, hab ich natürlich gleich mal ein paar probleme.

    Kurz vorweg, Ich nutze einen Arduino Mega 2560 (china Clone) 3m ws2812b /60LED/m led stripe die ich über eine Software wie Jinx oder Glediator ansteuern möchte. Dazu benutze ich die ino von Glediator

    Quellcode

    1. //##############################################################################
    2. //##############################################################################
    3. // #
    4. // Glediator to WS2812 pixel converter #
    5. // by R. Heller #
    6. // V 1.0 - 07.01.2014 #
    7. // wwww.SolderLab.de #
    8. // #
    9. // Receives serial data in Glediator protocol format @ 1 MBit/s #
    10. // and distributes it to a connectect chain of WS2812 pixels #
    11. // #
    12. // Adjust the correct DATA PIN and the correct NUMBER OF PIXELS you are using #
    13. // in the definitions section below before uploading this sketch to your #
    14. // Arduino device. #
    15. // #
    16. // Maxiumim number of supported pixeles is 512 !!! #
    17. // #
    18. // In the Glediator software set output mode to "Glediator_Protocol", #
    19. // color order to "GRB" and baud rate to "1000000" #
    20. // #
    21. //##############################################################################
    22. //##############################################################################
    23. //##############################################################################
    24. // #
    25. // Definitions --> Make changes ONLY HERE #
    26. // #
    27. // To find out the correct port, ddr and pin name when you just know the #
    28. // Arduino's digital pin number just google for "Arduino pin mapping". #
    29. // In the present example digital Pin 6 is used which corresponds to "PORTD", #
    30. // "DDRD" and "6", respectively. #
    31. // #
    32. //##############################################################################
    33. #define DATA_PORT PORTD
    34. #define DATA_DDR DDRD
    35. #define DATA_PIN 5 //mein Ausgabe Pin
    36. #define NUMBER_OF_PIXELS 180 //Anzahl meiner LED´s
    37. //##############################################################################
    38. // #
    39. // Variables #
    40. // #
    41. //##############################################################################
    42. unsigned char display_buffer[NUMBER_OF_PIXELS * 3];
    43. static unsigned char *ptr;
    44. static unsigned int pos = 0;
    45. volatile unsigned char go = 0;
    46. //##############################################################################
    47. // #
    48. // Setup #
    49. // #
    50. //##############################################################################
    51. void setup()
    52. {
    53. // Set data pin as output
    54. DATA_DDR |= (1 << DATA_PIN);
    55. // Initialize UART
    56. UCSR0A |= (1<<U2X0);
    57. UCSR0B |= (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0);
    58. UCSR0C |= (1<<UCSZ01) | (1<<UCSZ00) ;
    59. UBRR0H = 0;
    60. UBRR0L = 1; //Baud Rate 1 MBit (at F_CPU = 16MHz)
    61. ptr=display_buffer;
    62. //Enable global interrupts
    63. sei();
    64. }
    65. //##############################################################################
    66. // #
    67. // Main loop #
    68. // #
    69. //##############################################################################
    70. void loop()
    71. {
    72. if (go==1)
    73. {
    74. cli();
    75. ws2812_sendarray(display_buffer, NUMBER_OF_PIXELS * 3);
    76. sei();
    77. go=0;
    78. }
    79. }
    80. //##############################################################################
    81. // #
    82. // UART-Interrupt-Prozedur (called every time one byte is compeltely received) #
    83. // #
    84. //##############################################################################
    85. ISR(USART_RX_vect)
    86. {
    87. unsigned char b;
    88. b=UDR0;
    89. if (b == 1) {pos=0; ptr=display_buffer; return;}
    90. if (pos == (NUMBER_OF_PIXELS*3)) {} else {*ptr=b; ptr++; pos++;}
    91. if (pos == ((NUMBER_OF_PIXELS*3)-1)) {go=1;}
    92. }
    93. //##############################################################################
    94. // #
    95. // WS2812 output routine #
    96. // Extracted from a ligh weight WS2812 lib by Tim (cpldcpu@gmail.com) #
    97. // Found on wwww.microcontroller.net #
    98. // Requires F_CPU = 16MHz #
    99. // #
    100. //##############################################################################
    101. void ws2812_sendarray(uint8_t *data,uint16_t datlen)
    102. {
    103. uint8_t curbyte,ctr,masklo;
    104. uint8_t maskhi = _BV(DATA_PIN);
    105. masklo =~ maskhi & DATA_PORT;
    106. maskhi |= DATA_PORT;
    107. while (datlen--)
    108. {
    109. curbyte = *data++;
    110. asm volatile
    111. (
    112. " ldi %0,8 \n\t" // 0
    113. "loop%=:out %2, %3 \n\t" // 1
    114. "lsl %1 \n\t" // 2
    115. "dec %0 \n\t" // 3
    116. " rjmp .+0 \n\t" // 5
    117. " brcs .+2 \n\t" // 6l / 7h
    118. " out %2,%4 \n\t" // 7l / -
    119. " rjmp .+0 \n\t" // 9
    120. " nop \n\t" // 10
    121. " out %2,%4 \n\t" // 11
    122. " breq end%= \n\t" // 12 nt. 13 taken
    123. " rjmp .+0 \n\t" // 14
    124. " rjmp .+0 \n\t" // 16
    125. " rjmp .+0 \n\t" // 18
    126. " rjmp loop%= \n\t" // 20
    127. "end%=: \n\t"
    128. : "=&d" (ctr)
    129. : "r" (curbyte), "I" (_SFR_IO_ADDR(DATA_PORT)), "r" (maskhi), "r" (masklo)
    130. );
    131. }
    132. }
    133. //##############################################################################
    134. // #
    135. // End of program #
    136. // #
    137. //##############################################################################


    Jinx so wie Glediator Senden daten im Glediator Protokoll. Ja sie senden Daten (TX led Flackert und Blinkt wie irre 8| ) aber das ist die einzige LED die Flackert, die Stripes bleiben Dunkel. Strom und alles ist an und Versorgt die led mit ausreichend Spannung, (Getestet über FastLED Beispiel) mit dem Beispielen von FastLED funktioniert auch alles nur leider nicht mit der Glediator firmware.

    Jetzt die Frage, woran kann das liegen? An der Hardware eher nicht die Funktioiert, meine vermutung an der Firmware die die signale die sie empfängt nicht an die led Weitergibt.

    BITTE bitte ich könnte da echt etwas hilfe gebrauchen^^
    Bilder
    • glediator.jpg

      140,53 kB, 532×335, 1.813 mal angesehen
    Ist F_CPU auch per Fuses richtig eingestellt? Die Vermutung bei so etwas liegt Nahe, dass das Timing nicht stimmt. Weiterhin einfach mal den USB-Empfang raus nehmen und nur ein paar Dummy-Daten in den Puffer schreiben und ausgeben. Wenn das funktioniert, dauert der Datenempfang zu lange.

    Aber eigentlich sehe ich da gar keine so richtige Protkoll-Routine. Ist denn das Glediator-Protokoll so einfach, dass er nur permanent Datenbytes sendet?
    nun ich muss zugeben das ich mich bei dem thema arduin und so noch so gut wie garnicht auskenne, ich weis das ich die leds damit ansteuern kann und auch bereits habe über die FastLed geschichte, aber bis jetzt hab ich noch keine ahnung wie ich was mit dem ding machen soll oder kann.

    ich weis nur das er irgendwelche daten empfängt, (blinkende TX led) aber die daten nicht an die led´s weiter gibt. zwecks der pinbelegung, bin ich alle PWM und Digitale pins durchgegangen (0- 53) aber ohne erfolg. bei 0 werden ein paar leds grün und eine weis wenn ich über glediator arbeite. aber das wars dann auch schon.

    wenn ich jetzt wüsste wie das datenpacket von glediator oder Jinx aussieht und wie es empfangen wird, könnte man eine einfache rgb steuerung damit realisieren.

    also z.b. den datenstrom Via Variable empfangen und in einer solchen codezeile einfügen.

    Quellcode

    1. #include <Adafruit_NeoPixel.h>
    2. #define PIN 0
    3. Adafruit_NeoPixel strip = Adafruit_NeoPixel(180, PIN, NEO_GRB + NEO_KHZ800);
    4. void setup() {
    5. strip.begin();
    6. strip.show();
    7. }
    8. void loop() {
    9. uint32_t c;
    10. c = strip.Color(10, 10, 10);
    11. for(uint16_t i=0; i < strip.numPixels(); i++) {
    12. strip.setPixelColor(i, c);
    13. }
    14. strip.show();
    15. }


    dann zum beispiel an die stelle
    strip.setPixelColor dann einen datenwert einfügen. beispielsweise wenn aus der software dann z.b. ein rgb wert kommt mit |Led_num|R|G|B| und die daten dann in die zeile einfügt. doch ich hab keine ahnung in welchem format das glediator protokoll arbeitet.

    Denn so wie im oberen codebeispiel leuchten alle led´s

    Alternativ könnte man ja das tpm2 Protokoll benutzen, evtl gibt es da mehr erfolg.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „djnijo“ ()

    Nunja, einfach mal ein Stück Quellcode kopieren und hoffen, dass etwas funktioniert, ist schwierig, wenn es nicht der komplette Code für eine Zweck ist. Schau mal in den Glediator-Thread, ich denke, da war auch was zum Arduino-Code geschrieben. Weiß aber nicht genau, ob es den gibt oder was der macht. Ansonsten nimm ein fertiges SEDUv3 o.ä. Board. Damit kannst Du direkt loslegen.
    also von den sedu boards halte ich momentan nicht all zu viel da diese auf 256 led begrenzt sind, so wie ich das bei einem gelesen habe.

    Alternativ ginge natürlich auch das TPM2 Protokoll, bei diesem hab ich zumindest mir dem Testcode den ich im Netz gefunden habe schon einen Blinker nachdem die Serial Verbíndung aufgebaut wurde.

    nur hab ich damit leider Auch noch keinen rechten erfolg verbuchen können. liegt evtl daran das ich warscheinlich noch ein paar parameter falsch habe.

    Im debug modus konnte ich zumindest mal einen befehl hin und her senden so das ich antwort vom arduino erhalte. doch die programme davon hab ich nicht zum laufen gebracht.

    C-Quellcode

    1. #include <pt.h>
    2. #include "FastLED.h"
    3. /*==============================================================================*/
    4. /* LED und Arduino Variablen */
    5. /*==============================================================================*/
    6. #define NUM_LEDS 40 // Number of LEDs
    7. #define MAX_ARGS 10 // Max Number of command arguments
    8. #define BAUDRATE 500000 // Baudrate
    9. #define SERIAL Serial // Serial port for communication
    10. #define SERIAL_DEBUG Serial // Serial port for debugging
    11. #define DATA_PIN 6 // PIN where LEDs are connected/Used for TM1809/WS2811 chipsets, because they dont use SPI
    12. //#define CLOCK_PIN 4 // used for some SPI chipsets, e.g. WS2801
    13. #define BRIGHTNESS 255 // define global brightness 0..255
    14. //choose your LED chipset in void setup()
    15. /*==============================================================================*/
    16. /* TPM2 Variablen */
    17. /*==============================================================================*/
    18. enum Protocol
    19. {
    20. // positions
    21. posStart = 0,
    22. posType = 1,
    23. posFsHigh = 2,
    24. posFsLow = 3,
    25. posData = 4,
    26. // bytes
    27. tpm2Start = 0xc9,
    28. tpm2DataFrame = 0xda,
    29. tpm2Command = 0xc0,
    30. tpm2Answer = 0xaa,
    31. tpm2End = 0x36,
    32. tpm2Ack = 0xAC
    33. };
    34. enum Mode
    35. {
    36. mNone,
    37. mCommunication,
    38. mProgram
    39. };
    40. struct Data
    41. {
    42. int pos;
    43. uint8_t type;
    44. uint16_t fs;
    45. uint8_t command;
    46. CRGB rgb[NUM_LEDS];
    47. } data;
    48. byte args[MAX_ARGS];
    49. unsigned long lastDataAt = 0;
    50. int program = 0;
    51. int mode = mNone;
    52. int effectDelay = 100;
    53. static struct pt pt1;
    54. /*==============================================================================*/
    55. /* Variablen für Effekte */
    56. /*==============================================================================*/
    57. int BOTTOM_INDEX = 0;
    58. int TOP_INDEX = int(NUM_LEDS/2);
    59. int EVENODD = NUM_LEDS%2;
    60. /*==============================================================================*/
    61. /* debug code
    62. /*==============================================================================*/
    63. // comment this line out to disable debugging
    64. //#define DEBUG
    65. #ifdef DEBUG
    66. void debug(const char* str)
    67. {
    68. SERIAL_DEBUG.println(str);
    69. }
    70. void debug(const char* str, uint16_t val, int fmt = DEC)
    71. {
    72. SERIAL_DEBUG.print(str);
    73. SERIAL_DEBUG.println(val, fmt);
    74. }
    75. int freeRam()
    76. {
    77. extern int __heap_start, *__brkval;
    78. int v;
    79. return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
    80. }
    81. #else
    82. # define debug( ... )
    83. #endif
    84. void setup()
    85. {
    86. SERIAL.begin(BAUDRATE);
    87. delay(1000);
    88. memset(data.rgb, 0, sizeof(struct CRGB) * NUM_LEDS);
    89. // Uncomment one of the following lines for your leds arrangement.
    90. // FastLED.addLeds<TM1803, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    91. // FastLED.addLeds<TM1804, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    92. // FastLED.addLeds<TM1809, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    93. // FastSPI_LED2.addLeds<WS2811, DATA_PIN, GRB>(data.rgb+18, NUM_LEDS/3);
    94. // FastLED.addLeds<WS2811, 8, RGB>(data.rgb + 225, NUM_LEDS/4);
    95. // FastLED.addLeds<WS2812, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    96. // FastLED.addLeds<WS2812B, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    97. FastLED.addLeds<NEOPIXEL, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    98. // FastLED.addLeds<WS2811_400, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    99. // FastLED.addLeds<UCS1903, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    100. // FastLED.addLeds<WS2801, RGB>(data.rgb, NUM_LEDS);
    101. // FastLED.addLeds<SM16716, RGB>(data.rgb, NUM_LEDS);
    102. // FastLED.addLeds<LPD8806, RGB>(data.rgb, NUM_LEDS);
    103. // FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, RGB>(data.rgb, NUM_LEDS);
    104. // FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, RGB>(data.rgb, NUM_LEDS);
    105. // FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, RGB>(data.rgb, NUM_LEDS);
    106. // FastLED.addLeds<WS2811, DATA_PIN, RGB>(data.rgb, NUM_LEDS);
    107. FastLED.setBrightness(BRIGHTNESS);
    108. oneColorAll(255,0,0);
    109. #ifdef DEBUG
    110. SERIAL_DEBUG.begin(BAUDRATE);
    111. // wait for serial port to connect. Needed for Leonardo only
    112. while (!SERIAL_DEBUG)
    113. delay(1);
    114. SERIAL_DEBUG.println("Setup done");
    115. #endif
    116. memset(args, 0, MAX_ARGS);
    117. resetVars();
    118. PT_INIT(&pt1);
    119. }
    120. /*==============================================================================*/
    121. /* Thread für Programm/Effekte
    122. /*==============================================================================*/
    123. static int playProgramThread(struct pt *pt)
    124. {
    125. static unsigned long timestamp = 0;
    126. PT_BEGIN(pt);
    127. while(1)
    128. {
    129. PT_WAIT_UNTIL(pt, millis() - timestamp > effectDelay);
    130. playProgram();
    131. timestamp = millis();
    132. }
    133. PT_END(pt);
    134. }
    135. /*==============================================================================*/
    136. /* loop
    137. /*==============================================================================*/
    Das Glediator-Protokoll ist eigentlich ganz einfach: eine "1" kennzeichnet den Start des Datenblocks, danach kommen die RGB-Werte. In diesen darf dann der Wert 1 natürlich nicht enthalten sein, den entfernt die Senderoutine (k.A., ob sie dann 2 oder 0 draus macht).

    Du musst so viele Bytes senden, wie die Empfangsroutine erwartet. Sonst tritt der Fall if (pos == ((NUMBER_OF_PIXELS*3)-1)) {go=1;} nie ein, es werden also nie Daten ausgegeben. Sollte aber bei Dir passen, Du hast ja 180 Pixel eingetragen und auch 180 in Glediator gepatcht.

    Du kannst ja mal in der Main Loop das if (go==1) raus machen, dann sollte er den Puffer immer ausgeben, egal ob nun was rein gekommen ist oder nicht. Da im RAM nach dem Reset zufällige Werte stehen, sollten die LEDs dann also irgendwie bunt leuchten. Bleiben sie aus, dann stimmt was an der Ausgaberoutine nicht.

    Leuchten Sie bunt, dann stimmt was an der Empfangsroutine oder Ausgabe am PC nicht.

    P.S.: wer behauptet, dass das SEDU-Board nur 256 Pixel kann.?!? - sogar das alte kann schon 1.024...
    It's only light - but we like it!

    Da es sich in letzter Zeit häuft: Ich beantworte keine PNs mit Fragen, die sich auch im Forum beantworten lassen!
    Insbesondere solche von Mitgliedern mit 0 Beiträgen, die dann meist auch noch Sachen fragen, die bereits im entsprechenden Thread beantwortet wurden.
    Ich bin keine private Bastler-Hotline, technische Tipps etc. sollen möglichst vielen Lesern im Forum helfen!

    Quellcode

    1. void loop()
    2. {
    3. while (1)
    4. {
    5. // if data available switch to communication mode
    6. if (SERIAL.available() > 0)
    7. {
    8. if (mode != mCommunication)
    9. {
    10. debug("switching to communication mode");
    11. mode = mCommunication;
    12. resetVars();
    13. }
    14. doCommunication();
    15. }
    16. else
    17. // communication timeout after 0.5 seconds
    18. while (SERIAL.available() == 0 && millis()-lastDataAt > 1000)
    19. {
    20. if (mode != mProgram)
    21. {
    22. debug("switching to prg mode, ignoring ", data.pos);
    23. mode = mProgram;
    24. resetVars();
    25. }
    26. else
    27. playProgramThread(&pt1);
    28. }
    29. }
    30. }
    31. /*==============================================================================*/
    32. /* do communication
    33. /*==============================================================================*/
    34. void doCommunication()
    35. {
    36. #ifdef DEBUG
    37. int count = 0;
    38. #endif
    39. // read ...
    40. while (SERIAL.available() > 0)
    41. {
    42. byte val = SERIAL.read();
    43. lastDataAt = millis();
    44. #ifdef DEBUG
    45. debug("got: ", val, HEX);
    46. debug("at pos: ", data.pos, DEC);
    47. count++;
    48. #endif
    49. if (data.pos == posStart && val == tpm2Start) // Startbyte
    50. resetVars();
    51. else if (data.pos == posType && (val == tpm2DataFrame || val == tpm2Command)) // Block-Art
    52. data.type = val;
    53. else if (data.pos == posFsHigh) // Framesize (High Bit)
    54. {
    55. data.fs = (val << 8) & 0xFF00;
    56. if (data.fs > NUM_LEDS*3)
    57. {
    58. debug("framsize too high: ", data.fs);
    59. resetVars();
    60. continue;
    61. }
    62. }
    63. else if (data.pos == posFsLow) // Framesize (Low byte)
    64. {
    65. data.fs += val & 0x00FF;
    66. if (data.fs > NUM_LEDS*3)
    67. {
    68. debug("framsize too high: ", data.fs);
    69. resetVars();
    70. continue;
    71. }
    72. }
    73. else if (data.pos == posData + data.fs && val == tpm2End) // End Byte
    74. parsePacket();
    75. else if (data.pos >= posData && data.pos < posData+data.fs) // Bytes zwischen Header und Ende lesen
    76. evaluateData(val);
    77. else // protocol violation ...
    78. {
    79. if (data.pos != 0)
    80. {
    81. debug("protocol violation at pos: ", data.pos);
    82. debug("val was: ", val);
    83. }
    84. debug("Error");
    85. resetVars();
    86. continue;
    87. }
    88. data.pos++;
    89. }

    Quellcode

    1. #ifdef DEBUG
    2. if (count)
    3. debug("received", count, DEC);
    4. #endif
    5. }
    6. /*==============================================================================*/
    7. /* evaluate data
    8. /*==============================================================================*/
    9. void evaluateData(byte val)
    10. {
    11. if (data.type == tpm2DataFrame) // frame data
    12. {
    13. uint8_t* rgb = (uint8_t*)data.rgb;
    14. rgb[data.pos-posData] = val;
    15. }
    16. else // command data
    17. {
    18. if (data.pos == posData)
    19. {
    20. data.command = val;
    21. memset(args, 0, sizeof(args));
    22. }
    23. else
    24. args[data.pos-posData-1] = val;
    25. }
    26. }
    27. /*==============================================================================*/
    28. /* reset variables
    29. /*==============================================================================*/
    30. void resetVars()
    31. {
    32. debug("Reset");
    33. memset(&data, 0, sizeof(Data));
    34. //data.rgb = (struct CRGB*)FastSPI_LED.getRGBData();
    35. memset(data.rgb, 0, NUM_LEDS * sizeof(struct CRGB));
    36. }
    37. /*==============================================================================*/
    38. /* parse packet
    39. /*==============================================================================*/
    40. void parsePacket()
    41. {
    42. debug("Parse");
    43. switch (data.type)
    44. {
    45. case tpm2DataFrame:
    46. {
    47. showLeds();
    48. break;
    49. }
    50. case tpm2Command:
    51. {
    52. setProgram();
    53. break;
    54. }
    55. default:
    56. break;
    57. }
    58. SERIAL.write(tpm2Ack);
    59. resetVars();
    60. data.pos = -1;
    61. }
    62. /*==============================================================================*/
    63. /* set LED color
    64. /*==============================================================================*/
    65. void setLedColor(int led, uint8_t r, uint8_t g, uint8_t b)
    66. {
    67. data.rgb[led].r = r;
    68. data.rgb[led].g = g;
    69. data.rgb[led].b = b;
    70. }
    71. /*==============================================================================*/
    72. /* one Color All
    73. /*==============================================================================*/
    74. void oneColorAll(uint8_t r, uint8_t g, uint8_t b)
    75. {
    76. memset(data.rgb, 0, NUM_LEDS * sizeof(struct CRGB));
    77. for (int led = 0; led < NUM_LEDS; led++)
    78. setLedColor(led, r, g, b);
    79. showLeds();
    80. effectDelay = 1000;
    81. }
    82. /*==============================================================================*/
    83. /* Output Leds
    84. /*==============================================================================*/
    85. void showLeds()
    86. {
    87. FastLED.show();
    88. }
    89. void setProgram()
    90. {
    91. program = data.command;
    92. }
    93. void playProgram()
    94. {
    95. switch (program)
    96. {
    97. case 0: oneColorAll(args[0],args[1],args[2]); break;
    98. case 1: loopRGBPixel(50); break;
    99. case 2: rainbow_fade(20); break;
    100. case 3: rainbow_loop(20); break;
    101. case 4: random_burst(20); break;
    102. case 5: flicker(200,255); break;
    103. case 6: colorBounce(200,50); break;
    104. case 7: pulse_oneColorAll(200,50,100,0); break;
    105. case 8: pulse_oneColorAll(0,50,100,1); break;
    106. case 9: police_light_strobo(50); break;
    107. case 10: police_lightsALL(20); break;
    108. case 11: police_lightsONE(20); break;
    109. default: oneColorAll(0,0,0); break;
    110. }
    111. }
    112. /* Set LED Color of given LED */
    113. void oneColorAllNOSHOW(int r, int g, int b)
    114. {
    115. resetVars();
    116. for (int led = 0; led < NUM_LEDS; led++)
    117. {
    118. setLedColor(led, r, g, b);
    119. }
    120. }
    121. /*==============================================================================*/
    122. /* Effect 0: Fixed color - Arguments RR GG BB
    123. /*==============================================================================*/
    124. /*==============================================================================*/
    125. /* Effect 1: Loops each RGB color through each Pixel
    126. /*==============================================================================*/
    127. void loopRGBPixel(int idelay) //OK
    128. {
    129. static int c = 0;
    130. static int i = 0;
    131. if (i > NUM_LEDS-1)
    132. {
    133. i = 0;
    134. c++;
    135. }
    136. if (c == 3)
    137. c = 0;
    138. memset(data.rgb, 0, NUM_LEDS*3);
    139. switch (c)
    140. {
    141. case 0:
    142. data.rgb[i].r =200;
    143. break;
    144. case 1:
    145. data.rgb[i].g =200;
    146. break;
    147. case 2:
    148. data.rgb[i].b =200;
    149. break;
    150. }
    151. showLeds();
    152. effectDelay = idelay;
    153. i++;
    154. }
    155. /*==============================================================================*/
    156. /* Effect 2: Fade through raibow colors over all LEDs
    157. /*==============================================================================*/
    158. void rainbow_fade(int idelay) { //OK //-FADE ALL LEDS THROUGH HSV RAINBOW
    159. static int ihue = -1;
    160. ihue++;
    161. if (ihue >= 255) {
    162. ihue = 0;
    163. }
    164. for(int idex = 0 ; idex < NUM_LEDS; idex++ ) {
    165. data.rgb[idex] = CHSV(ihue, 255, 255);
    166. }
    167. showLeds();
    168. effectDelay = idelay;
    169. }
    170. /*==============================================================================*/
    171. /* Effect 3: Loops rainbow colors around the stripe
    172. /*==============================================================================*/
    173. void rainbow_loop(int idelay) { //-LOOP HSV RAINBOW
    174. static double idex = 0;
    175. static double ihue = 0;
    176. double steps = (double)255/NUM_LEDS;
    177. for(int led = 0 ; led < NUM_LEDS; led++ ) {
    178. ihue = led * steps + idex;
    179. if (ihue >= 255)
    180. ihue -= 255;
    181. data.rgb[led] = CHSV((int)ihue, 255, 255);
    182. if (led == 0)
    183. idex += steps;
    184. if (idex >= 255)
    185. idex = 0;
    186. }
    187. showLeds();
    188. effectDelay = idelay;
    189. }
    190. /*==============================================================================*/
    191. /* Effect 4: Random burst - Randowm colors on each LED
    192. /*==============================================================================*/
    193. void random_burst(int idelay) { //-RANDOM INDEX/COLOR
    194. static int idex = 0;
    195. static int ihue = 0;
    196. idex = random(0,NUM_LEDS-1);
    197. ihue = random(0,255);
    198. data.rgb[idex] = CHSV(ihue, 255, 255);
    199. showLeds();
    200. effectDelay = idelay;
    201. }
    202. /*==============================================================================*/
    203. /* Effect 5: Flicker effect - random flashing of all LEDs
    204. /*==============================================================================*/
    205. void flicker(int thishue, int thissat) {
    206. int ibright = random(0,255);
    207. int random_delay = random(10,100);
    208. for(int i = 0 ; i < NUM_LEDS; i++ ) {
    209. data.rgb[i] = CHSV(thishue, thissat, ibright);
    210. }
    211. showLeds();
    212. effectDelay = random_delay;
    213. }
    214. /*==============================================================================*/
    215. /* Effect 6: Color bounce - bounce a color through whole stripe
    216. /*==============================================================================*/
    217. void colorBounce(int ihue, int idelay) { //-BOUNCE COLOR (SINGLE LED)
    218. static int bouncedirection = 0;
    219. static int idex = 0;
    220. if (bouncedirection == 0) {
    221. idex = idex + 1;
    222. if (idex == NUM_LEDS) {
    223. bouncedirection = 1;
    224. idex = idex - 1;
    225. }
    226. }
    227. if (bouncedirection == 1) {
    228. idex = idex - 1;
    229. if (idex == 0) {
    230. bouncedirection = 0;
    231. }
    232. }
    233. for(int i = 0; i < NUM_LEDS; i++ ) {
    234. if (i == idex) {
    235. data.rgb[i] = CHSV(ihue, 255, 255);
    236. }
    237. else {
    238. setLedColor(i, 0, 0, 0);
    239. }
    240. }
    241. showLeds();
    242. effectDelay = idelay;
    243. }
    244. /*==============================================================================*/
    245. /* Effect 7/8: Fade in/out a color using brightness/saturation
    246. /*==============================================================================*/

    Quellcode

    1. void pulse_oneColorAll(int ahue, int idelay, int steps, int useSat) { //-PULSE BRIGHTNESS ON ALL LEDS TO ONE COLOR
    2. static int bouncedirection = 0;
    3. static int idex = 0;
    4. int isteps = 255/steps;
    5. static int ival = 0;
    6. static int xhue = 0;
    7. if (bouncedirection == 0) {
    8. ival += isteps;
    9. if (ival >= 255) {
    10. bouncedirection = 1;
    11. }
    12. }
    13. if (bouncedirection == 1) {
    14. ival -= isteps;
    15. if (ival <= 0) {
    16. bouncedirection = 0;
    17. xhue = random(0, 255);
    18. }
    19. }
    20. for(int i = 0 ; i < NUM_LEDS; i++ ) {
    21. if (useSat == 0)
    22. data.rgb[i] = CHSV(xhue, 255, ival);
    23. else
    24. data.rgb[i] = CHSV(xhue, ival, 255);
    25. }
    26. showLeds();
    27. effectDelay = idelay;
    28. }
    29. /*==============================================================================*/
    30. /* Effect 9: Police light - red/blue strobo on each half of stripe
    31. /*==============================================================================*/
    32. void police_light_strobo(int idelay)
    33. {
    34. int middle = NUM_LEDS/2;
    35. static int color = 0;
    36. static int left_right = 0;
    37. if (left_right > 19)
    38. left_right = 0;
    39. if (color == 1)
    40. color = 0;
    41. else
    42. color = 1;
    43. for (int i = 0; i < NUM_LEDS; i++)
    44. {
    45. if (i <= middle && left_right < 10)
    46. {
    47. if (color)
    48. setLedColor(i, 0, 0, 255);
    49. else
    50. setLedColor(i, 0, 0, 0);
    51. }
    52. else
    53. if (i > middle && left_right >= 10)
    54. {
    55. if (color)
    56. setLedColor(i, 255, 0, 0);
    57. else
    58. setLedColor(i, 0, 0, 0);
    59. }
    60. }
    61. showLeds();
    62. effectDelay = idelay;
    63. left_right++;
    64. }
    65. /*==============================================================================*/
    66. /* Effect 10: Police Light all LEDs
    67. /*==============================================================================*/
    68. void police_lightsALL(int idelay) { //-POLICE LIGHTS (TWO COLOR SOLID)
    69. static int idex = 0;
    70. int idexR = idex;
    71. int idexB = antipodal_index(idexR);
    72. setLedColor(idexR, 255, 0, 0);
    73. setLedColor(idexB, 0, 0, 255);
    74. showLeds();
    75. effectDelay = idelay;
    76. idex++;
    77. if (idex >= NUM_LEDS) {
    78. idex = 0;
    79. }
    80. }
    81. /*==============================================================================*/
    82. /* Effect 11: Police Light one LED blue and red
    83. /*==============================================================================*/
    84. void police_lightsONE(int idelay) { //-POLICE LIGHTS (TWO COLOR SINGLE LED)
    85. static int idex = 0;
    86. int idexR = idex;
    87. int idexB = antipodal_index(idexR);
    88. for(int i = 0; i < NUM_LEDS; i++ ) {
    89. if (i == idexR) {
    90. setLedColor(i, 255, 0, 0);
    91. }
    92. else if (i == idexB) {
    93. setLedColor(i, 0, 0, 255);
    94. }
    95. else {
    96. setLedColor(i, 0, 0, 0);
    97. }
    98. }
    99. showLeds();
    100. effectDelay = idelay;
    101. idex++;
    102. if (idex >= NUM_LEDS) {
    103. idex = 0;
    104. }
    105. }
    106. /*==============================================================================*/
    107. /* Util func Effekte */
    108. /*==============================================================================*/
    109. //-FIND INDEX OF ANTIPODAL OPPOSITE LED
    110. int antipodal_index(int i) {
    111. //int N2 = int(NUM_LEDS/2);
    112. int iN = i + TOP_INDEX;
    113. if (i >= TOP_INDEX) {
    114. iN = ( i + TOP_INDEX ) % NUM_LEDS;
    115. }
    116. return iN;
    117. }