Array, wie? und wie verändern?

[Tobias N. (silberkristall)]

Hi leute,

ich brauche für ein projekt mal eure Hilfe.

Also es geht um ws2811/ws2812 LEDs. es hängen 250 Stück hintereinander.

Ich dachte somit an ein Array z.b. namens LED

Wie muss ich dieses Array nun bauen?

Also ich dachte mir das so, LED[1] beinhaltet die werte R,G,B also 
müsste das Array ja aussehen LED[1] = ( 255,255,255 )

Wie erstelle ich so ein Array? wie komme ich an die Werte usw usw?

Dann möchte ich einzelne Werte ändern können also beim Initialisieren 
sollen alle LEDs aus sein, somit muss das array LED 1 - 150 jeweils die 
werte 0,0,0 haben.

Wie komme ich jetzt an die einzelnen LED Werte? und wie kann ich einen 
Wert im Array verändern ohne die anderen zu berühen? Also z.b. nur LED 
117 auf 255,255,255 setzen?

Dann würde ich das ganze noch gerne per "Random" füllen lassen können, 
also wirkürlich werden werte gesetzt.

Kann mir da jemand weiter helfen?

Danke euch schonmal.

[Bitflüsterer (Gast)]

Du könntest eine geeignete Programmiersprache lernen und Dein Vorhaben 
mit deren Mitteln realisieren.

[Coder (Gast)]

typedef struct
{
    uint8_t R;
    uint8_t G;
    uint8_t B;
} RGB_t;


#define LED_CNT   250U

typedef struct
{
    RGB_t LED_Data[LED_CNT];
} RGB_Data_t;

Mit der Idee mal spielen...

[Tobias N. (silberkristall)]

ich hatte da mal so angefangen, nur bin ich noch nicht soweit das ich 
weiss ob das so klappt oder nicht.

Hier mal der Code:

ws2811.h

#define WSDDR DDRA
#define WSPORT PORTA
#define WSPIN PA1
#define ledanzahl 100 // 1 - 1024

void ws2811_reset(void);
void ws2811_init(void);
void wswrite_zero(void);
void wswrite_one(void);
void ws2811_rgbsetall(int r, int g, int b);

void ws2811_rgbsetone(int led, int r, int g, int b);
void ws2811_send(void);

// erstelle ledarray

int leds[ledanzahl][3];

ws2811.c

#include <avr/io.h>
#include <util/delay.h>
#include "ws2811.h"

void ws2811_reset(void)
{
  WSPORT &= ~(1<<WSPIN);
  _delay_us(55);
}

void wswrite_zero(void)
{
  // 500ns +- 150ns high
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  // 2000ns +- 150ns low
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
}

void wswrite_one(void)
{
  // 1200ns +- 150ns high
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  WSPORT |= (1<<WSPIN); // 125ns
  // 1300ns +- 150ns low
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
  WSPORT &= ~(1<<WSPIN); // 125ns
}

void ws2811_rgbsetall(int r, int g, int b) // ws2811_rgbsetall(0,0,0) = alle aus
{
  for(int i=0;i<ledanzahl;i++)
   {
     leds[i][0] = r;
   leds[i][1] = g;
   leds[i][2] = b;
   }
}

void ws2811_rgbsetone(int led, int r, int g, int b)
{
  leds[led][0] = r;
  leds[led][1] = g;
  leds[led][2] = b;
}

void ws2811_send(void)
{
  for (int ws11=0; ws11<ledanzahl; ws11++)
    {
      
      // Rot
    if (leds[ws11][0] & 1<<1) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][0] & 1<<2) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][0] & 1<<3) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][0] & 1<<4) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][0] & 1<<5) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][0] & 1<<6) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][0] & 1<<7) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][0] & 1<<8) { wswrite_one(); } else { wswrite_zero(); }
    
    // Grün
    if (leds[ws11][1] & 1<<1) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][1] & 1<<2) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][1] & 1<<3) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][1] & 1<<4) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][1] & 1<<5) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][1] & 1<<6) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][1] & 1<<7) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][1] & 1<<8) { wswrite_one(); } else { wswrite_zero(); }
    
    // Blau
    if (leds[ws11][2] & 1<<1) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][2] & 1<<2) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][2] & 1<<3) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][2] & 1<<4) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][2] & 1<<5) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][2] & 1<<6) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][2] & 1<<7) { wswrite_one(); } else { wswrite_zero(); }
    if (leds[ws11][2] & 1<<8) { wswrite_one(); } else { wswrite_zero(); }
    }
}

void ws2811_init(void)
{
  // Port als Ausgang setzen
  WSDDR |= (1<<WSPIN);
  // Reset
  ws2811_reset();
  // alle leds aus
  ws2811_rgbsetall(0,0,0);
  // senden
  ws2811_send();
}

[Lutz H. (luhe)]

Es sind drei unterschiedliche Probleme.

1. Wie werden die Werte im Rechner abgespeichert.
2. Wie werden die Werte berechnet.
3. Wie werden die berechneten Werte ausgegeben.

1. Man kann mehrdimensionale Arrays mutzen,ich würde
vorschlagen drei Eindimensionale Arrays zu Nutzen,
z.B.:
int Rot[256];
int Grün[256];
int Gelb[256};

Setzen:

Rot[117]=1;
Grün[117]=1;
Gelb[117}=1;

Zufallszahlen werden mit der RND , Random oder ähnlichen berechnet.

Die zufällige Folge wäre dann:

For (int i=0;i<256;i++){

Rnd;      // hier einem Zufallswert zwischen 0 und 1 berechnen undin Rnd 
abspeichen

(if Rnd>0.5) Rot[i]=1;
(if Rnd<=0.5) Rot[i]=0;
Rnd
(if Rnd>0.5) Grün[i]=1;
(if Rnd<=0.5) Grün[i]=0;
Rnd
(if Rnd>0.5) Gelb[i]=1;
(if Rnd<=0.5) Gelb[i]=0;

ws2811_rgbsetone(i, Rot[i], Grün[i], Gelb[i])
}


Die Ausgabe je nach Prozessor.
void ws2811_rgbsetone(int led, int r, int g, int b);
void ws2811_send(void);

[Tobias N. (silberkristall)]

ok,

und die helligkeit würde mich noch interessieren, also wenn ich nur z.b. 
0,0,0 - 255,0,0 ändere dann wird Rot von 0 - 255 heller, aber wenn ich 
farben "mische" und da die werte immer nur -1 oder +1 änder dann ändert 
sich nicht die helligkeit sondern auch die farbe weil andere werte.

zum einsatz kommt ein atmega128 mit 16Mhz Quarz

[icke (Gast)]

Schau dir mal den HSV-Farbraum an.
Der setzt sich - im gegensatz zu RGB - aus der Farbe (H = Hue), der 
Sättigung (S = Saturation) und Dunkelheit (V= Value) zusammen.

H wird im allgemeinen als Grad in Farbenkreis angegeben.
0 ist zum Beispiel Rot.
Wenn du jetzt den V-Wert veränderst, wird die Helligkeit vom Rot 
geändert

[Fuzzi59 (Gast)]

Du könntest auch ein sogenanntes jagged Array benutzen. Das ist ein 
Array in dem du Arrays des gleichen Typs(String, Int32, Double, usw.) 
speichern kannst. Ich würde dann drei Arrays, für je eine Farbe, in 
einem Jagged-Array speichern:

            int[][] RGB = new int[3][];
            RGB[0][0] = 0;//Wert aus Array (0) an der Stelle 0
            RGB[1][0] = 0;//Wert aus Array (1) an der Stelle 0
            RGB[2][0] = 0;//Wert aus Array (2) an der Stelle 0

Hier noch ein Link zum besseren Verständnis: 
http://msdn.microsoft.com/de-de/library/2s05feca.aspx

[Max H. (hartl192)]

Oder man könnte auch ein Array auf 24bit Variablen machen und in jeder 
Variable alle 3 RGB-Werte speichern.

LED[5]=(red_8bit<<16)|(green_8bit<<8)|(blue_8bit);

[Coder (Gast)]

Native 24-Bit Variable auf einem AVR ist wohl optimistisch.