Array, wie? und wie verändern?

Tobias N. OP #3672748
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Tobias N. OP #3672783
Lesenswert?
• ▲
▼ 
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
1
#define WSDDR DDRA

2
#define WSPORT PORTA

3
#define WSPIN PA1

4
#define ledanzahl 100 // 1 - 1024

5


6
void ws2811_reset(void);

7
void ws2811_init(void);

8
void wswrite_zero(void);

9
void wswrite_one(void);

10
void ws2811_rgbsetall(int r, int g, int b);

11


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

13
void ws2811_send(void);

14


15
// erstelle ledarray

16


17
int leds[ledanzahl][3];



ws2811.c
1
#include <avr/io.h>

2
#include <util/delay.h>

3
#include "ws2811.h"

4


5
void ws2811_reset(void)

6
{

7
  WSPORT &= ~(1<<WSPIN);

8
  _delay_us(55);

9
}

10


11
void wswrite_zero(void)

12
{

13
  // 500ns +- 150ns high

14
  WSPORT |= (1<<WSPIN); // 125ns

15
  WSPORT |= (1<<WSPIN); // 125ns

16
  // 2000ns +- 150ns low

17
  WSPORT &= ~(1<<WSPIN); // 125ns

18
  WSPORT &= ~(1<<WSPIN); // 125ns

19
  WSPORT &= ~(1<<WSPIN); // 125ns

20
  WSPORT &= ~(1<<WSPIN); // 125ns

21
  WSPORT &= ~(1<<WSPIN); // 125ns

22
  WSPORT &= ~(1<<WSPIN); // 125ns

23
  WSPORT &= ~(1<<WSPIN); // 125ns

24
  WSPORT &= ~(1<<WSPIN); // 125ns

25
  WSPORT &= ~(1<<WSPIN); // 125ns

26
  WSPORT &= ~(1<<WSPIN); // 125ns

27
  WSPORT &= ~(1<<WSPIN); // 125ns

28
  WSPORT &= ~(1<<WSPIN); // 125ns

29
  WSPORT &= ~(1<<WSPIN); // 125ns

30
  WSPORT &= ~(1<<WSPIN); // 125ns

31
  WSPORT &= ~(1<<WSPIN); // 125ns

32
  WSPORT &= ~(1<<WSPIN); // 125ns

33
}

34


35
void wswrite_one(void)

36
{

37
  // 1200ns +- 150ns high

38
  WSPORT |= (1<<WSPIN); // 125ns

39
  WSPORT |= (1<<WSPIN); // 125ns

40
  WSPORT |= (1<<WSPIN); // 125ns

41
  WSPORT |= (1<<WSPIN); // 125ns

42
  WSPORT |= (1<<WSPIN); // 125ns

43
  WSPORT |= (1<<WSPIN); // 125ns

44
  WSPORT |= (1<<WSPIN); // 125ns

45
  WSPORT |= (1<<WSPIN); // 125ns

46
  WSPORT |= (1<<WSPIN); // 125ns

47
  WSPORT |= (1<<WSPIN); // 125ns

48
  // 1300ns +- 150ns low

49
  WSPORT &= ~(1<<WSPIN); // 125ns

50
  WSPORT &= ~(1<<WSPIN); // 125ns

51
  WSPORT &= ~(1<<WSPIN); // 125ns

52
  WSPORT &= ~(1<<WSPIN); // 125ns

53
  WSPORT &= ~(1<<WSPIN); // 125ns

54
  WSPORT &= ~(1<<WSPIN); // 125ns

55
  WSPORT &= ~(1<<WSPIN); // 125ns

56
  WSPORT &= ~(1<<WSPIN); // 125ns

57
  WSPORT &= ~(1<<WSPIN); // 125ns

58
  WSPORT &= ~(1<<WSPIN); // 125ns

59
}

60


61
void ws2811_rgbsetall(int r, int g, int b) // ws2811_rgbsetall(0,0,0) = alle aus

62
{

63
  for(int i=0;i<ledanzahl;i++)

64
   {

65
     leds[i][0] = r;

66
   leds[i][1] = g;

67
   leds[i][2] = b;

68
   }

69
}

70


71
void ws2811_rgbsetone(int led, int r, int g, int b)

72
{

73
  leds[led][0] = r;

74
  leds[led][1] = g;

75
  leds[led][2] = b;

76
}

77


78
void ws2811_send(void)

79
{

80
  for (int ws11=0; ws11<ledanzahl; ws11++)

81
    {

82
      

83
      // Rot

84
    if (leds[ws11][0] & 1<<1) { wswrite_one(); } else { wswrite_zero(); }

85
    if (leds[ws11][0] & 1<<2) { wswrite_one(); } else { wswrite_zero(); }

86
    if (leds[ws11][0] & 1<<3) { wswrite_one(); } else { wswrite_zero(); }

87
    if (leds[ws11][0] & 1<<4) { wswrite_one(); } else { wswrite_zero(); }

88
    if (leds[ws11][0] & 1<<5) { wswrite_one(); } else { wswrite_zero(); }

89
    if (leds[ws11][0] & 1<<6) { wswrite_one(); } else { wswrite_zero(); }

90
    if (leds[ws11][0] & 1<<7) { wswrite_one(); } else { wswrite_zero(); }

91
    if (leds[ws11][0] & 1<<8) { wswrite_one(); } else { wswrite_zero(); }

92
    

93
    // Grün

94
    if (leds[ws11][1] & 1<<1) { wswrite_one(); } else { wswrite_zero(); }

95
    if (leds[ws11][1] & 1<<2) { wswrite_one(); } else { wswrite_zero(); }

96
    if (leds[ws11][1] & 1<<3) { wswrite_one(); } else { wswrite_zero(); }

97
    if (leds[ws11][1] & 1<<4) { wswrite_one(); } else { wswrite_zero(); }

98
    if (leds[ws11][1] & 1<<5) { wswrite_one(); } else { wswrite_zero(); }

99
    if (leds[ws11][1] & 1<<6) { wswrite_one(); } else { wswrite_zero(); }

100
    if (leds[ws11][1] & 1<<7) { wswrite_one(); } else { wswrite_zero(); }

101
    if (leds[ws11][1] & 1<<8) { wswrite_one(); } else { wswrite_zero(); }

102
    

103
    // Blau

104
    if (leds[ws11][2] & 1<<1) { wswrite_one(); } else { wswrite_zero(); }

105
    if (leds[ws11][2] & 1<<2) { wswrite_one(); } else { wswrite_zero(); }

106
    if (leds[ws11][2] & 1<<3) { wswrite_one(); } else { wswrite_zero(); }

107
    if (leds[ws11][2] & 1<<4) { wswrite_one(); } else { wswrite_zero(); }

108
    if (leds[ws11][2] & 1<<5) { wswrite_one(); } else { wswrite_zero(); }

109
    if (leds[ws11][2] & 1<<6) { wswrite_one(); } else { wswrite_zero(); }

110
    if (leds[ws11][2] & 1<<7) { wswrite_one(); } else { wswrite_zero(); }

111
    if (leds[ws11][2] & 1<<8) { wswrite_one(); } else { wswrite_zero(); }

112
    }

113
}

114


115
void ws2811_init(void)

116
{

117
  // Port als Ausgang setzen

118
  WSDDR |= (1<<WSPIN);

119
  // Reset

120
  ws2811_reset();

121
  // alle leds aus

122
  ws2811_rgbsetall(0,0,0);

123
  // senden

124
  ws2811_send();

125
}
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Lutz H. #3672788
Lesenswert?
• ▲
▼ 
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);
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Tobias N. OP #3672795
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
icke Gast #3672870
Lesenswert?
• ▲
▼ 
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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Fuzzi59 Gast #3674093
Lesenswert?
• ▲
▼ 
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:
1
            int[][] RGB = new int[3][];

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

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

4
            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
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren