Go Down

Topic: array mit variablen (Read 1 time) previous topic - next topic

mkl0815

Vor den voids bedeutet vermutlich vor der Definition von "void setup()" und "void loop()".

currymuetze

Hi,
ok, ist wohl doch etwas komplexer, also kurz ein paar mehr Details:

Mein code funktioniert so, dass ich RTC gesteuert stündlich 2 Dimmwerte abfrage: z.B. pwmchannel[0][hour] und pwmchannel[0][hour+1].
Dahinter liegt dann eine Methode, die meine LED uhrzeitgesteuert hoch/runterdimmt, indem die beiden Werte verglichen werden:
Sieht so aus:
Code: [Select]

void fadeLight() {
  for (pinCount=0; pinCount<15; pinCount++) {
    if (hour<23) bruch[pinCount] = (float)3600 / (PWMchannel[pinCount][hour+1] - PWMchannel[pinCount][hour]);
    if (hour==23) bruch[pinCount] = (float)3600 / (PWMchannel[pinCount][0] - PWMchannel[pinCount][hour]);
    i[pinCount] = PWMchannel[pinCount][hour] + ((3600 - (3600 - ((mins * 60) + (sec * 1)))) / bruch[pinCount]);
  }
}


Was damit allerdings nicht geht, ist dass ich quasi auf minutenbasis dimme, sprich ich möcht zu bestimmten Stunden noch etwas genauer dimmen, also in 10 Minuten Abständen bestimmte Werte angeben können.
Dazu habe ich mir eine neue FUnktion und entsprehcendes Array gebaut:
Code: [Select]

                                //  0   | 10  | 20  | 30  | 40  | 50
const int SunSetValues[5] [6] = { { 3500, 3600, 4095, 4095, 4095, 4095 },
                                  { 3500, 3600, 3700, 4095, 4095, 4095 },
                                  { 3500, 3600, 3700, 3800, 4095, 4095 },
                                  { 3500, 3600, 3700, 3800, 3900, 4095 },
                                  { 3500, 3600, 3700, 3800, 3900, 3950 } };

void SunSet() {
  if (mins<50) {
    for (pinCount=0; pinCount<5; pinCount++) {
      if (mins==0 || mins%10==0) {
        bruchss[pinCount] = (float)600 / (SunSetValues[pinCount][(mins/10)+1] - SunSetValues[pinCount][(mins/10)]);
        valuess[pinCount] = SunSetValues[pinCount][(mins/10)]; /// Zwischenlagerung des Wertes für mins/10
      }
      ss[pinCount] = valuess[pinCount] + ((600 - (600 - (((mins%10) * 60) + (sec * 1)))) / bruchss[pinCount]); //mins%10 => was bei mins = 0?? oder 1???
    }
  }
  if (mins>=50) {
    for (pinCount=0; pinCount<5; pinCount++) {
      if (pinCount<4) ss[pinCount] = 4095;
      if (pinCount==4) {
        if (mins%10==0) {
          bruchss[pinCount] = (float)600 / (m[4][hour] - SunSetValues[pinCount][(mins/10)]);
          valuess[pinCount] = SunSetValues[pinCount][(mins/10)];
        }
        ss[pinCount] = valuess[pinCount] + ((600 - (600 - (((mins%10) * 60) + (sec * 1)))) / bruchss[pinCount]);
      }
    }
  }
}


Die ganze Berechnung und soweiter funktioniert perfekt. Nur halt nicht dass die Werte in meine Hauptarray übergeben werden. Daran scheitert es.

VG



michael_x

Quote
wohl doch etwas komplexer
Meine volle Zustimmung ;)
Was ich verstanden hab:
- PWMchannel enthält Stundenwerte, lineares Interpolieren ist dir aber zu grob.

Was ich nicht verstanden habe:
- bruch ist nur eine temporäre Variable, warum ein array, warum global, warum float ?
- das Ergebnis von fadeLight wird in einem globalen Array namens i abgelegt. Das glaub ich nicht ?!
- was ist dein "Hauptarray" 
- Damit du eine feinere Auflösung kriegst, willst du dynamisch diese Stundenwerte ändern ?


Funktionen heissen Funktionen, weil sie aus Eingangswerten etwas berechnen und das als Ergebnis zurückliefern.

Ich könnte mir gut eine Funktion  int fadeLight(const int * PWMHours, int hour, int minute)  vorstellen, die du für jeden Channel einmal aufrufst und die gar keine globalen Variablen braucht, weil sie die benötigten Stundenwerte gleich mitgeliefert bekommt und dadurch für jeden Channel verwendbar ist.

currymuetze

Hi,
also was mir wichtig war bei der Funktion: Wenn der arduino mal ausfällt und wieder angeht, soll er direkt mit dem korrekten PWM Wert starten. Darum hab ich das in Abhängigkeit von der RTC gemacht. Das nur am Rande, das funktioniert super.

Im Array PWM Channel habe ich die Start/Endzeiten pro Stunde gespeichert. SO kann der Arduino um 17:11:25 sich den korrekten Wert ziehen, der zwischen 17 und 18h errechnet wird. Das wird hier linear interpoliert, das ist richtig.

allerdings möchte ich gerne zu bestimmten Uhrzeiten den Fade etwas feiner gestalten. Daher habe ich da ne Variable eingefügt, die dann widerrum über eine 2te FUnktion errechnet wird.

Zu deinen Fragen:
- bruch ist in der tat temporär. Ich definiere irgendwie immer alle variablen global. Ist das kontraproduktiv? Float musste sein, da die zwischenergebnisse auch nachkommastellen liefern. Hatte da hin und her probiert und nur mit float klappte es.

- was meinst du mit "glaub ich nicht"? Ist das nicht sinnvoll? i[] ist der Wert, der dann an den TLC weitergegeben wird.

- das Hauptarray ist das PWM Channel

- genau - an bestimmten Zeiten will ich nen feineren Sonnenauf/untergang simulieren.  (das ganze ist für ne Aquariumbeleuchtung)

VG


currymuetze


Funktionen heissen Funktionen, weil sie aus Eingangswerten etwas berechnen und das als Ergebnis zurückliefern.

Ich könnte mir gut eine Funktion  int fadeLight(const int * PWMHours, int hour, int minute)  vorstellen, die du für jeden Channel einmal aufrufst und die gar keine globalen Variablen braucht, weil sie die benötigten Stundenwerte gleich mitgeliefert bekommt und dadurch für jeden Channel verwendbar ist.


so ganz seh ich den vorteil noch nicht... das array bleibt doch dann inkl. der arrays/variablen im array?

Wie ist der Ansatz hier?

Code: [Select]

void PWMvalue() {
  for (pinCount=0; pinCount<15; pinCount++) {
    i[pinCount] = fadeLight(mins, sec, PWMchannel[pinCount][hour+1], PWMchannel[pinCount][hour]);
  }
}

int fadeLight(int minute, int sekunde, const int* PWMvaluebald, const int* PWMvaluejetzt) {
  float bruch = (float)3600 / WMvaluebald - PWMvaluejetzt;
  int result;
  result = PWMvaluejetzt + ((3600 - (3600 - ((minuten * 60) + (sekunden * 1)))) / bruch);
  return result;
}

Go Up