Beiträge von Rom77

    den Sketch habe ich hier vom Forum, das Hochfahren auf das Arduinoboard klappt... nur das wars dann auch schon



    // Glediator to WS2812 pixel converter #

    // by R. Heller #

    // V 1.0 - 07.01.2014 #

    // wwww.SolderLab.de #

    // #

    // Receives serial data in Glediator protocol format @ 1 MBit/s #

    // and distributes it to a connectect chain of WS2812 pixels #

    // #

    // Adjust the correct DATA PIN and the correct NUMBER OF PIXELS you are using #

    // in the definitions section below before uploading this sketch to your #

    // Arduino device. #

    // #

    // Maxiumim number of supported pixeles is 512 !!! #

    // #

    // In the Glediator software set output mode to "Glediator_Protocol", #

    // color order to "GRB" and baud rate to "1000000" #

    // #

    //##############################################################################

    //##############################################################################


    //##############################################################################

    // #

    // Definitions --> Make changes ONLY HERE #

    // #

    // To find out the correct port, ddr and pin name when you just know the #

    // Arduino's digital pin number just google for "Arduino pin mapping". #

    // In the present example digital Pin 6 is used which corresponds to "PORTD", #

    // "DDRD" and "6", respectively. #

    // #

    //##############################################################################


    #define DATA_PORT PORTD

    #define DATA_DDR DDRD

    #define DATA_PIN 5

    #define NUMBER_OF_PIXELS 496


    //##############################################################################

    // #

    // Variables #

    // #

    //##############################################################################


    unsigned char display_buffer[NUMBER_OF_PIXELS * 3];

    static unsigned char *ptr;

    static unsigned int pos = 0;


    volatile unsigned char go = 0;


    //##############################################################################

    // #

    // Setup #

    // #

    //##############################################################################


    void setup()

    {

    // Set data pin as output

    DATA_DDR |= (1 << DATA_PIN);


    // Initialize UART

    UCSR0A |= (1<<U2X0);

    UCSR0B |= (1<<RXEN0) | (1<<TXEN0) | (1<<RXCIE0);

    UCSR0C |= (1<<UCSZ01) | (1<<UCSZ00) ;

    UBRR0H = 0.2304;

    UBRR0L = 0.2304; //Baud Rate 1 MBit (at F_CPU = 16MHz)


    ptr=display_buffer;


    //Enable global interrupts

    sei();

    }


    //##############################################################################

    // #

    // Main loop #

    // #

    //##############################################################################


    void loop()

    {

    if (go==1)

    {

    cli();

    ws2812_sendarray(display_buffer, NUMBER_OF_PIXELS * 3);

    sei();

    go=0;

    }

    }


    //##############################################################################

    // #

    // UART-Interrupt-Prozedur (called every time one byte is compeltely received) #

    // #

    //##############################################################################


    ISR(USART0_RX_vect)

    {

    unsigned char b;

    b=UDR0;


    if (b == 1) {pos=0; ptr=display_buffer; return;}

    if (pos == (NUMBER_OF_PIXELS*3)) {} else {*ptr=b; ptr++; pos++;}

    if (pos == ((NUMBER_OF_PIXELS*3)-1)) {go=1;}

    }


    //##############################################################################

    // #

    // WS2812 output routine #

    // Extracted from a ligh weight WS2812 lib by Tim (cpldcpu@gmail.com) #

    // Found on wwww.microcontroller.net #

    // Requires F_CPU = 16MHz #

    // #

    //##############################################################################


    void ws2812_sendarray(uint8_t *data,uint16_t datlen)

    {

    uint8_t curbyte,ctr,masklo;

    uint8_t maskhi = _BV(DATA_PIN);

    masklo =~ maskhi & DATA_PORT;

    maskhi |= DATA_PORT;


    while (datlen--)

    {

    curbyte = *data++;


    asm volatile

    (

    " ldi %0,8 \n\t" // 0

    "loop%=:out %2, %3 \n\t" // 1

    "lsl %1 \n\t" // 2

    "dec %0 \n\t" // 3

    " rjmp .+0 \n\t" // 5

    " brcs .+2 \n\t" // 6l / 7h

    " out %2,%4 \n\t" // 7l / -

    " rjmp .+0 \n\t" // 9

    " nop \n\t" // 10

    " out %2,%4 \n\t" // 11

    " breq end%= \n\t" // 12 nt. 13 taken

    " rjmp .+0 \n\t" // 14

    " rjmp .+0 \n\t" // 16

    " rjmp .+0 \n\t" // 18

    " rjmp loop%= \n\t" // 20

    "end%=: \n\t"

    : "=&d" (ctr)

    : "r" (curbyte), "I" (_SFR_IO_ADDR(DATA_PORT)), "r" (maskhi), "r" (masklo)

    );

    }


    }

    habe den Sketch hochgeladen und anschließend Glediator gestartet. Ich habe mich an das Tutorial von hamburgtech gehalten. Ich kriege es aber einfach nicht hin, dass die Pixel leuchten. Also mit dem Arduiono ist alles okay, da die Beispiele von Neopixel und Fastled funktionieren. Ich weiß echt nicht mehr was ich machen soll.


    Irgendjemand eine Idee, wie ich sonst noch vorgehen könnte, um Fehler auszuschließen?

    also Java und RXTX sind installiert. Leider erreiche ich nicht Solderlab.de


    Soweit ich das richtig verstehe, brauche ich ja einen Sketch für Arduino. Weiß jemand wo ich diesen downloaden kann?

    und es werde Licht... meine Lampe leuchtet :)


    Ich habe zunächst einmal mit den Beispielen von NeoPixel und FASTLED bisschen gespielt, ich bin vom dem Effekt begeistert.


    Allerdings ist mir das Programmieren der Pixel mit FASTLED & Co. etwas zu abstrakt.


    Ich würde viel lieber Jinx! oder Glediator nutzen. Pesi danke für den Tipp. Habe mir beides installiert. Nur habe ich keinen blassen Schimmer was ich anstellen muss, damit diese mit meinem Arduino Uno kommunizieren:?:


    Ich möchte keinesfalls jemanden abverlangen meine Arbeit zu übernehmen. Nur weiß ich gar nicht so genau, wo ich beginnen soll. Ich würde mich aber über jeden Tipp freuen.

    Zitat

    Die SK6812 sind WS2811 kompatibel, was soll da nicht reinpassen. Infact merkt Fastled etc garnicht, welcher Chip dahinterhängt.

    es geht einfach um die Bauart, brauche keine Strips, die LEDs müssen in die Bälle rein

    Also ich möchte ja 12x WS2811 Pixel Strings in Reihe schalten, habe aber noch Fragen:


    Mir ist daran gelegen, dass die LEDs eine gleichmäßige, konstante Farbgebung haben. Die Farben des ersten Strings sollten, die des letzten gleichkommen. Da es nun knapp 600 LEDs sind, frage ich mich, ob das mit 5V zu realisieren ist. Wären da 12V nicht ratsamer? Was sind da die Grenzen?


    Bei 600 LEDs komme ich auf insgesamt 36A bzw. 180W. Ich habe gelesen, man solle einen Puffer von 25% einberechnen. Da ich ein Angeobt mit einem Netzteil von 200W 40A bekommen habe, frage ich mich, ob das nun reicht? In dem Fall wären es lediglich etwas über 10%.


    Wie sieht es mit der Stromversorgung aus? An jedem einzelnen String muss ich eine Spannung anlegen, richtig? Also es reicht nicht aus, dass ich eine Spannung an den ersten String anlege und dann die Strings lediglich mit den Steckern verbinde. Wie muss die Spannung an die letzte Kette angelegt werden? Mir ist das nicht ganz klar. Jeder String kriegt jeweils im Eingang eine Spannung. Wie muss der Ausgang am letzten String verbunden werden?


    Zuletzt die Sicherung noch. Muss ich am Spannungseingang eines jeden Strings eine Sicherung einsetzen? Welche Sicherung(en) muss ich verwenden?

    wenn du diesen Aufwand betreiben willst, dann tu dir selber den Gefallen und nimm SK6812


    danke für den Tipp, aber es muss schon eine WS2811 Kette sein, die SK6812 passen nicht in mein Setup. Mir ist mehr an den RGB Farben gelegen als an Weißtönen, obwohl Grautöne auch einen schönen Effekt hätten

    Welche Spannung hast du für die LEDs vorgesehen? Denn Leistung = Strom x Spannung (URI). Zudem würde ich von der Maximallsast aus mindestens 25% Reserve einberechnen. Welche Möglichkeiten hast du, den Arduino unabhängig von der Leuchte mit Energie zu versorgen?

    Hey danke für den Like :)

    es sollen 5V sein... also 585 x 60mA /1000 * 5V = 175W ... dachte da an ein 40A 200W Netzteil, eine Reserve etwas über 10%, reicht das nicht?

    da mein Arduino kein Wifi hat und ich den ja mit Code füttern muss, würde ich es zunächst einmal ganz normal per USB Kabel betreiben


    Man sieht in den Golfbällen (edit: ah, schmarrn, sind ja Tischtennisbälle) so kleine Löcher, denke mal, dass da in jedes eine LED rein soll

    richtig! Die Löcher haben 12mm, sodass ich mal hoffe das meine LEDs da fest sitzen werden, ohne dass ich da noch was kleben muss. Die LEDs haben einen Steg oder so, hoffe, dass es passt


    Ich würde das mit den 13 Strings von unten nach oben verkabeln. Ja, im Prinzip ist es egal, wie das verkabelt ist, man kann die Anordnung immer noch in der SW anpassen. Welche willst Du denn verwenden...? Prinzipiell kann man auch die Lampe in Unity in 3D nachbauen, und dann genau wissen, welches Pixel wo ist...

    werde mich wohl kreisförmig Ring für Ring nach oben arbeiten, alles andere ist glaube ich nicht durchsetzbar, mein Arm hat keine 2 Meter :)

    wollte mich erstmal mit FASTLED und Neopixel befassen... Was hat Unity mit LEDs zu tun? Mir ist der Bezug nicht ganz klar. Also ich kann ein 3D Model meiner Lampe erstellen und dann :/

    Hallo Forum!


    Mein Name ist Roman, ich bin Anfänger, was LED Beleuchtungen angeht und habe einige Fragen zu meinem kleinen Projekt. Ich schilder mal einfach und bitte um Eure Meinung, noch habe ich nichts bestellt und möchte auch nichts falsch machen.


    Also ich habe eine runde Stehlampe aus 585 Tischtennisbällen gebastelt, möchte also knapp 600 Pixel verwenden, in dem Fall die WS2811, habe da an die 5V Variante gedacht, insgesamt also 12 Strings. Ansteuern möchte ich das ganze zunächst über Arduino FastLEDs oder auch Vixen, bin aber auch für anderes offen. Als Netzteil dachte ich an 200W 40A (meine Rechnung 600 x 60 mA / 1000 also 36A mit einem kleinen Puffer also). Reichen Watt und Ampere?


    Das Netzteil soll mein Arduino Uno und die LEDs mit Strom versorgen. GND und + vom Netzteil zunächst einmal auf mein Arduino / GND und Data vom Arduino in meine Pixelkette und dann vom Netzteil GND und + in jeden einzelnen der 12 Strings. Ist meine Überlegung richtig?




    Eine weitere Frage, die sich mir stellt, ist wie ich die Pixel am besten anordnen soll. Mir kommen 3 Varianten in den Sinn. Der Umfang der Lampe besteht aus 13 PingPongs. Diese sind um einen halben PingPong jeweils versetzt aufeinander gestapelt, insgesamt 45 Ringe.


    Jetzt könnte ich mich ringförmig nach oben arbeiten, also den ersten Ring mit 13 Pixel bestücken, dann den zweiten und so weiter.


    Die 2. Variante wäre vielleicht, senkrecht nach oben. Da die PingPongs aber versetzt aufeinander sitzen, müsste ich im ZickZack mit dem String nach oben gehen (in diesem Fall bräuchte ich 13 Strings, da ja 13 Bälle im Umfang).


    Und die dritte Variante: 13 Strings, die sich jeweils spiralförmig von einem der 13 unteren Bällen um die Lampe herum nach oben ziehen. Jeder String quasi jeweils um einen halben Ball nach rechts oder links nach oben versetzt wird.... Wie ich die Pixel am besten anordne, ist mir nicht ganz klar, da ich keine Erfahrungen mit dem Programmieren habe, sei es jetzt FASTLED oder was anderem.


    Wenn die Bälle einmal mit den Pixel bestückt und diese verklebt sind, kann ich es nicht mehr rückgängig machen.




    Also ich würde mich riesig freuen, wenn Ihr mir Tipps geben könntet...