WS2801 - Arduino2560 Mega - Glediator - Verbindungsproblem

    WS2801 - Arduino2560 Mega - Glediator - Verbindungsproblem

    Hallo liebes Forum,
    nach langer Zeit des vielen lesen und lernen habe ich mich jetzt auch Angemeldet da ich dieses Problem leider nicht ohne Eure Hilfe lösen kann.
    Habe vor einiger Zeit den Arduino entdeckt und habe angefangen damit ein wenig herum zu experimentieren.
    Da ich mit Programmierung noch nie etwas zu tun hatte funktioniert doch schon einiges und kleine Sketche sind auch kaum ein Problem mehr - Dank ledstyles.de.
    Es wurden ja schon sehr viele Themen bahndelt und konnte mir soweit immer selber sehr gut helfen aber diesmal seid Ihr gefragt ;)
    Hoffe das mir hier geholfen wird und ich genauso meinen Erfolg und Freude daran habe =)

    folgendes habe ich Aufgebaut:
    externen Netzteil von einem PC - 5V, 22A
    WS2801 mit 142 RGB`s
    Arduino 2560 Mega über USB am PC angeschlossen

    Arduino Sketch von der Solderlab - solderlab.de/index.php/downloa…s2801-sketch-arduino-mega

    Quellcode

    1. //Arduino Mega Sketch to drive strands and matrices of WS2801 pixels with Glediator.
    2. //(c)2012 by R. Heller
    3. //wwww.solderlab.de
    4. //Set Baudrate in Glediator to 1MBit !!!
    5. //Change this to YOUR matrix size!!
    6. #define Num_Pixels 142
    7. //Serial Data Output (Arduino-Mega Pin 6)
    8. #define SDO_Port PORTH
    9. #define SDO_DDR DDRH
    10. #define SDO_Pin 2
    11. //Serial Data Clock (Arduino-Mega Pin 7)
    12. #define CLK_Port PORTH
    13. #define CLK_DDR DDRH
    14. #define CLK_Pin 3
    15. //############################################################################################################################################################
    16. // Don't change anything upon here! #
    17. //############################################################################################################################################################
    18. #define Set_CLK_Low CLK_Port &= ~(1 << CLK_Pin)
    19. #define Set_CLK_High CLK_Port |= (1 << CLK_Pin)
    20. #define Set_CLK_Output CLK_DDR |= (1 << CLK_Pin)
    21. #define Set_SDO_Low SDO_Port &= ~(1 << SDO_Pin)
    22. #define Set_SDO_High SDO_Port |= (1 << SDO_Pin)
    23. #define Set_SDO_Output SDO_DDR |= (1 << SDO_Pin)
    24. #define CMD_NEW_DATA 1
    25. unsigned char display_buffer[Num_Pixels * 3];
    26. static unsigned char *ptr;
    27. static unsigned int pos = 0;
    28. volatile unsigned char go = 0;
    29. void setup()
    30. {
    31. Set_SDO_Output;
    32. Set_CLK_Output;
    33. //Disable global interrupts
    34. cli();
    35. //UART Initialisation
    36. UCSR0A |= (1<<U2X0);
    37. UCSR0B |= (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0);
    38. UCSR0C |= (1<<UCSZ01) | (1<<UCSZ00) ;
    39. UBRR0H = 0;
    40. UBRR0L = 1; //Baud Rate 1 MBit
    41. ptr=display_buffer;
    42. //Enable global interrupts
    43. sei();
    44. }
    45. void loop()
    46. {
    47. if (go==1) {shift_out_data(); go=0;}
    48. }
    49. // USART-Interrupt-Prozedur (called every time one byte is compeltely received) #
    50. ISR(USART0_RX_vect)
    51. {
    52. unsigned char b;
    53. b=UDR0;
    54. if (b == CMD_NEW_DATA) {pos=0; ptr=display_buffer; return;}
    55. if (pos == (Num_Pixels*3)) {} else {*ptr=b; ptr++; pos++;}
    56. if (pos == ((Num_Pixels*3)-1)) {go=1;}
    57. }
    58. // Shift out Data #
    59. void shift_out_data()
    60. {
    61. for (int i=0; i<Num_Pixels; i++)
    62. {
    63. byte r = display_buffer[i*3+0];
    64. byte g = display_buffer[i*3+1];
    65. byte b = display_buffer[i*3+2];
    66. for (byte j=0; j<8; j++)
    67. {
    68. Set_CLK_Low;
    69. if (r & (1<<(7-j))) {Set_SDO_High;} else {Set_SDO_Low;}
    70. Set_CLK_High;
    71. }
    72. for (byte j=0; j<8; j++)
    73. {
    74. Set_CLK_Low;
    75. if (g & (1<<(7-j))) {Set_SDO_High;} else {Set_SDO_Low;}
    76. Set_CLK_High;
    77. }
    78. for (byte j=0; j<8; j++)
    79. {
    80. Set_CLK_Low;
    81. if (b & (byte)(1<<(7-j))) {Set_SDO_High;} else {Set_SDO_Low;}
    82. Set_CLK_High;
    83. }
    84. }
    85. Set_CLK_Low;
    86. delayMicroseconds(800); //Latch Data
    87. }


    zum Glediator Programm - OUTPUT:
    Glediator_Protocol
    Single_PixelsCOM Port: COM3
    Baud-Rate: B_1000000
    vorab will ich noch sagen das der Strip hervorragend schon funktioniert mit der Library von AdafruitWS2801 - Strandtest

    C-Quellcode

    1. #include "Adafruit_WS2801.h"
    2. #include "SPI.h" // Comment out this line if using Trinket or Gemma
    3. #ifdef __AVR_ATtiny85__
    4. #include <avr/power.h>
    5. #endif
    6. /*****************************************************************************
    7. Example sketch for driving Adafruit WS2801 pixels!
    8. Designed specifically to work with the Adafruit RGB Pixels!
    9. 12mm Bullet shape ----> https://www.adafruit.com/products/322
    10. 12mm Flat shape ----> https://www.adafruit.com/products/738
    11. 36mm Square shape ----> https://www.adafruit.com/products/683
    12. These pixels use SPI to transmit the color data, and have built in
    13. high speed PWM drivers for 24 bit color per pixel
    14. 2 pins are required to interface
    15. Adafruit invests time and resources providing this open source code,
    16. please support Adafruit and open-source hardware by purchasing
    17. products from Adafruit!
    18. Written by Limor Fried/Ladyada for Adafruit Industries.
    19. BSD license, all text above must be included in any redistribution
    20. *****************************************************************************/
    21. // Choose which 2 pins you will use for output.
    22. // Can be any valid output pins.
    23. // The colors of the wires may be totally different so
    24. // BE SURE TO CHECK YOUR PIXELS TO SEE WHICH WIRES TO USE!
    25. uint8_t dataPin = 2; // Yellow wire on Adafruit Pixels
    26. uint8_t clockPin = 3; // Green wire on Adafruit Pixels
    27. // Don't forget to connect the ground wire to Arduino ground,
    28. // and the +5V wire to a +5V supply
    29. // Set the first variable to the NUMBER of pixels. 25 = 25 pixels in a row
    30. Adafruit_WS2801 strip = Adafruit_WS2801(142, dataPin, clockPin);
    31. // Optional: leave off pin numbers to use hardware SPI
    32. // (pinout is then specific to each board and can't be changed)
    33. //Adafruit_WS2801 strip = Adafruit_WS2801(25);
    34. // For 36mm LED pixels: these pixels internally represent color in a
    35. // different format. Either of the above constructors can accept an
    36. // optional extra parameter: WS2801_RGB is 'conventional' RGB order
    37. // WS2801_GRB is the GRB order required by the 36mm pixels. Other
    38. // than this parameter, your code does not need to do anything different;
    39. // the library will handle the format change. Examples:
    40. //Adafruit_WS2801 strip = Adafruit_WS2801(25, dataPin, clockPin, WS2801_GRB);
    41. //Adafruit_WS2801 strip = Adafruit_WS2801(25, WS2801_GRB);
    42. void setup() {
    43. #if defined(__AVR_ATtiny85__) && (F_CPU == 16000000L)
    44. clock_prescale_set(clock_div_1); // Enable 16 MHz on Trinket
    45. #endif
    46. strip.begin();
    47. // Update LED contents, to start they are all 'off'
    48. strip.show();
    49. }
    50. void loop() {
    51. // Some example procedures showing how to display to the pixels
    52. colorWipe(Color(255, 0, 0), 50);
    53. colorWipe(Color(0, 255, 0), 50);
    54. colorWipe(Color(0, 0, 255), 50);
    55. rainbow(20);
    56. rainbowCycle(20);
    57. }
    58. void rainbow(uint8_t wait) {
    59. int i, j;
    60. for (j=0; j < 256; j++) { // 3 cycles of all 256 colors in the wheel
    61. for (i=0; i < strip.numPixels(); i++) {
    62. strip.setPixelColor(i, Wheel( (i + j) % 255));
    63. }
    64. strip.show(); // write all the pixels out
    65. delay(wait);
    66. }
    67. }
    68. // Slightly different, this one makes the rainbow wheel equally distributed
    69. // along the chain
    70. void rainbowCycle(uint8_t wait) {
    71. int i, j;
    72. for (j=0; j < 256 * 5; j++) { // 5 cycles of all 25 colors in the wheel
    73. for (i=0; i < strip.numPixels(); i++) {
    74. // tricky math! we use each pixel as a fraction of the full 96-color wheel
    75. // (thats the i / strip.numPixels() part)
    76. // Then add in j which makes the colors go around per pixel
    77. // the % 96 is to make the wheel cycle around
    78. strip.setPixelColor(i, Wheel( ((i * 256 / strip.numPixels()) + j) % 256) );
    79. }
    80. strip.show(); // write all the pixels out
    81. delay(wait);
    82. }
    83. }
    84. // fill the dots one after the other with said color
    85. // good for testing purposes
    86. void colorWipe(uint32_t c, uint8_t wait) {
    87. int i;
    88. for (i=0; i < strip.numPixels(); i++) {
    89. strip.setPixelColor(i, c);
    90. strip.show();
    91. delay(wait);
    92. }
    93. }
    94. /* Helper functions */
    95. // Create a 24 bit color value from R,G,B
    96. uint32_t Color(byte r, byte g, byte b)
    97. {
    98. uint32_t c;
    99. c = r;
    100. c <<= 8;
    101. c |= g;
    102. c <<= 8;
    103. c |= b;
    104. return c;
    105. }
    106. //Input a value 0 to 255 to get a color value.
    107. //The colours are a transition r - g -b - back to r
    108. uint32_t Wheel(byte WheelPos)
    109. {
    110. if (WheelPos < 85) {
    111. return Color(WheelPos * 3, 255 - WheelPos * 3, 0);
    112. } else if (WheelPos < 170) {
    113. WheelPos -= 85;
    114. return Color(255 - WheelPos * 3, 0, WheelPos * 3);
    115. } else {
    116. WheelPos -= 170;
    117. return Color(0, WheelPos * 3, 255 - WheelPos * 3);
    118. }
    119. }


    Jetzt zu meinem Problem:

    Der Glediator Sketch ist hochgeladen auf den Arduino, Glediator wie oben beschrieben eingestellt.
    Ich gehe davon aus wenn die TX led auf dem Board "schnell" am "Dauerblinken" ist, besteht die USB Verbindung von PC zu dem Arduino?!
    Den Strip möchte ich NUR in der länge verwenden. D.h. X=142 Y=1 - würde dies überhaupt funktionieren?
    Ausprobiert habe ich es auch mit X=71 Y=2, anderster ist es nicht machbar um das ich genau auf die 142 Pixel komme.
    Zerschneiden oder abschneiden will ich erst einmal vermeiden wobei eine Matrix doch auch nur in Reihe geschaltet ist oder?
    Das USB Kabel ist auch nur 1 Meter lang.
    Weiteres kann ich leider nicht ausschließen.
    Woran kann es liegen das der Strip nichts anzeigt?
    Habe ich irgend etwas übersehen?

    Danke vorab für alle kommenden Beiträge.

    Gruß RmK
    Hast du mal ausgerechnet, welcher Strom bei 140x weiß fließt? 3x 0,02A x 140 macht stattliche 8,4 Ampere!
    Du magst ein Netzteil haben, welches 22A liefern kann, aber hast du auch elektrisch die Voraussetzungen geschaffen, das das funktioniert?
    Das ist in etwa so, als wenn du eine Feuerwehrspritze zwar an einem Hydranten, aber mit einem Gartenschlauch betreiben willst :evil:
    Mit welchem Kabelquerschnitt speist du ein?
    Wie lang sind die Kabel vom Netzteil zum Stripe?
    An wievielen Stellen speist du ein?
    Hast du an den Einspeisepunkten nochmals low ESR Elkos? (Größenordnung 1000µF)?
    Nur der Querschnitt des Stripes und eine Einspeisung reichen nicht aus! Deshalb leuchten die LEDs auch nicht mit voller Helligkeit, weil die Spannung einbricht. Das die letzten 3 nur blau leuchten, deutet ebenfalls darauf hin, das dort nichts mehr ankommt. Wenn die Spannung einbricht, langt die Spannung nicht mehr für den Logikteil in der LED und der Stripe "fährt sich fest" und reagiert nicht mehr auf weitere Kommandos.
    Lasse erst mal einen einzigen Lichtpunkt durch den Stripe laufen. Dann fließen nur 60mA ;)
    Es gibt WS2812 Modelle, da sind 2 Farben vertauscht. Das kannst du per Software aber ggf. ausgleichen.
    Wenn die Software mitspielt, dann kümmerst du dich um die Stromversorgung. Aber beides zusammen wird nichts. Du weißt dann nie, ob du ein elektrisches, oder ein Softwareproblem hast.
    Für die Jüngeren: Led Zeppelin ist KEIN beleuchtetes Luftschiff! :D
    Ja in Sachen elektronik müsste ich mich da noch reinarbeiten, ist auch ned so ganz mein Ding aber Danke das du mich darauf hinweist ;)
    Dazu muss ich sagen das einige DEMO Sketches wunderbar funktionieren bis ans Ende der Kette mit voller Helligkeit, deshalb würd ichs gern erstmal so stehen lassen da es ja funktioniert ;)
    Ich hab die Orginalkabel genommen und mit dem PC Netzteil direkt verbunden, speiße nur an einer Stelle ein.
    Des mit den 3 blauen LED - die waren hier und dort verteilt gewesen.

    Bin in der letzten halebn Stunde auch ein Stück weitergekommen und zwar:
    Bei diesem Beitrag LED-Matrix (15x12) Probleme mit der Kommunikation zwischen Arduino und Jinx / Glediator habe ich was gelesen - kleine Sketchänderung, viertletzter Beitrag..

    Dann habe ich einfach nur ein wenig ausprobiert in diesem Sketch

    Quellcode

    1. //Change this to YOUR matrix size!!
    2. #define Num_Pixels 142
    3. #define CMD_NEW_DATA 1
    4. int SDI = 2;
    5. int CKI = 3;
    6. unsigned char display_buffer[Num_Pixels * 3];
    7. static unsigned char *ptr;
    8. static unsigned int pos = 0;
    9. volatile unsigned char go = 0;
    10. void setup()
    11. {
    12. pinMode(SDI, OUTPUT);
    13. pinMode(CKI, OUTPUT);
    14. //UART Initialisation
    15. UCSR0A |= (1<<U2X0);
    16. UCSR0B |= (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0);
    17. UCSR0C |= (1<<UCSZ01) | (1<<UCSZ00) ;
    18. UBRR0H = 0;
    19. UBRR0L = 1; //Baud Rate 0.5 MBit --> 0% Error at 16MHz :-)
    20. ptr=display_buffer;
    21. //Enable global interrupts
    22. sei();
    23. }
    24. void loop()
    25. {
    26. if (go==0) {shift_out_data(); go=0;}
    27. }
    28. //############################################################################################################################################################
    29. // UART-Interrupt-Prozedur (called every time one byte is compeltely received) #
    30. //############################################################################################################################################################
    31. ISR(USART0_RX_vect)
    32. {
    33. unsigned char b;
    34. b=UDR0;
    35. if (b == CMD_NEW_DATA) {pos=0; ptr=display_buffer; return;}
    36. if (pos == (Num_Pixels*3)) {} else {*ptr=b; ptr++; pos++;}
    37. if (pos == ((Num_Pixels*3)-1)) {go=1;}
    38. }
    39. //############################################################################################################################################################
    40. // Shift out Data #
    41. //############################################################################################################################################################
    42. void shift_out_data()
    43. {
    44. for (int i=0; i<Num_Pixels; i++)
    45. {
    46. byte r = display_buffer[i*3+0];
    47. byte g = display_buffer[i*3+1];
    48. byte b = display_buffer[i*3+2];
    49. for (byte j=0; j<8; j++)
    50. {
    51. digitalWrite(CKI, LOW);
    52. if (b & (byte)(1<<(7-j))) {digitalWrite(SDI, HIGH);} else {digitalWrite(SDI, LOW);}
    53. digitalWrite(CKI, HIGH);
    54. }
    55. for (byte j=0; j<8; j++)
    56. {
    57. digitalWrite(CKI, LOW);
    58. if (r & (1<<(7-j))) {digitalWrite(SDI, HIGH);} else {digitalWrite(SDI, LOW);}
    59. digitalWrite(CKI, HIGH);
    60. }
    61. for (byte j=0; j<8; j++)
    62. {
    63. digitalWrite(CKI, LOW);
    64. if (g & (1<<(7-j))) {digitalWrite(SDI, HIGH);} else {digitalWrite(SDI, LOW);}
    65. digitalWrite(CKI, HIGH);
    66. }
    67. }
    68. digitalWrite(CKI, LOW);
    69. delayMicroseconds(800); //Latch Data
    70. }
    71. //############################################################################################################################################################
    72. //############################################################################################################################################################
    73. //############################################################################################################################################################


    HIER NUR DIE 1 AUF 0 GEÄNDERT

    Quellcode

    1. ​void loop()
    2. {
    3. if (go==1) {shift_out_data(); go=0;}
    4. }


    und schon bekommt die Kette meine Signale ABER die Farben stimmen nicht, Blau ist Rot usw usf.
    und nur ca 2/3 der 142 LED`s funktionieren. Ansonsten wird dies angezeigt was ich auf dem Bildschirm sehe.
    Achso noch zu erwähnen ist das es nur mit JINX soweit funktioniert, mit Glediator hatte ich bis jetzt keinen erfolg ausser das die erste LED reagiert sobald ich auf Start drücke und genauso wieder ausgeht wenn ich Stop drücke.

    Trotzdem erstmal Danke das du dich dem Thema annimmst ;)
    Ja Software ist auch ned so mein Ding ABER ich habs raus!!
    Bei Jinx im OUTPUT PATCH die genaue größe auch mit angeben, ich habs bissl größer gemacht damit ich gleich alle roten Kästchen erwische -> mein Fehler..
    Bei OUTPUT DEVICES:
    tmp2 anstatt Glediator
    COM 3 bei mir
    und die Baudrate auch auf 1000000
    naja jetzt läufts "eigentlich" bis auf die erste LED - die bleibt an auf blau ^^
    Wenns hilft:

    ich habe mir kürzlich einen Arduino Nachbau (Elegoo) beschafft. Und einen WS2812 Stripe mit 60 Pixeln.
    Und als erstes den Neopixel Sketch geladen und erweitert, dass alle 3 Farben + weiss durchlaufen.
    Einfach mal probieren...

    Gruß
    Bernd
    Dateien
    • Neopixel.txt

      (3,05 kB, 117 mal heruntergeladen, zuletzt: )

    BerndK schrieb:

    Wenns hilft:

    ich habe mir kürzlich einen Arduino Nachbau (Elegoo) beschafft. Und einen WS2812 Stripe mit 60 Pixeln.



    Er hat weder einen normalen Arduino noch einen WS2811 basierten Aufbau.

    naja jetzt läufts "eigentlich" bis auf die erste LED - die bleibt an auf blau


    Das hat sicher was mit dem Patchen zu tun. Warum patchst du eigentlich manuell? Also so dass du "die roten Kästchen" überhaupt als wichtig erachtet?

    Das geht doch alles automatisch über "Fast Patch"