Sollwertaufteilung mit oberen und unteren Grenzwerten

[nic_moe]

Zuviel Werbung?
-> Hier kostenlos registrieren

Hallo miteinander,

ich sitz hier grad vor einem mehr oder weniger großem Problem.

Ich habe einen Sollwert der auf 3 verschiedene Umrichter aufgeteilt werden soll. Die Umrichter haben dabei die Parameter "Umrichter Bereit", "Grenzwert oben" und "Grenzwert unten".

Der Sollwert soll nun auf die verfügbaren Umrichter aufgeteilt werden, muss jedoch die Grenzen, welche von Hand verstellbar sind, beachten.

Im einfachsten Wert habe ich dabei einen Wert von beispielsweise 60 MW der auf 3 verfügbare Umrichter verteilt wird. Die Umrichter haben eine grenze von jeweils 75 MW, sodass jeder 20MW bekommt.

Dies wäre ja kein Problem, allerdings kommen nun die Grenzen ins Spiel. Wenn ein Umrichter den Sollwert nicht abfahren kann, soll der Rest auf die anderen Umrichter aufgeteilt werden. Hier muss das Spiel jetzt rekursiv werden, da es vorkommen kann, das die Umrichtergrenze eines Umrichters erst mit dem Restwert des anderen verletzt wird.

Das ist leider nicht alles. Die Umrichter sollen auch noch rückspeisen können und im Phasenschieberbetrieb arbeiten können.

So kann es vorkommen das ich eine Gesamtleistung von 60 MW fordere.
Ich stell jetzt den oberen Grenzwert von UR1 auf -20MW und den unteren Grenzwert auf -40. Teile ich den Gesamtwert durch die 3 Umrichter, so soll jeder bekommen. Da bei UR1 der obere Grenzwert auf -20 steht müssen die anderen jeweils 40 fahren, damit ich in SUmme wieder bei 60 bin. Hier kann es jetzt passieren das einer der positiven Umrichter den oberen Grenzwert bei 30 hat, sodass UR1 -20 abfahren müsste, UR2 30 und UR2 50.

Die ganze Aufteilung ist somit nicht so ganz einfach, kann mir da jemand vielleicht einen Tipp geben wie man das am geeignetsten aufteilen kann?

Viele Grüße

nic

 

[StructuredTrash]

Habe mir mal die Mühe gemacht, meine Idee als Code zu schreiben, bzw. was heisst Mühe, als Roman wäre es wohl länger geworden.

TYPE stFU :
STRUCT
 PMin:REAL;
 PMax:REAL;
 PSoll:REAL;
 Bereit:BOOL;
 Frei:BOOL;
END_STRUCT
END_TYPE
 
PROGRAM MAIN
VAR
 FU:ARRAY[0..2] OF stFU;
 PMin:REAL;
 PMax:REAL;
 PSoll:REAL;
 PSollProFU:REAL;
 PRest:REAL;
 FreieFUs:BYTE;
 I:BYTE;
END_VAR
 
(* Gesamt-Ober-/Untergrenze und Anzahl verfügbarer FUs bestimmen *)
PMin:=0;
PMax:=0;
FreieFUs:=0;
FOR I:=0 TO 2 DO
 IF FU[I].Bereit
 THEN
  PMin:=PMin+FU[I].PMin;
  PMax:=PMax+FU[I].PMax;
  FreieFUs:=FreieFUs+1;
  FU[I].Frei:=TRUE;
 ELSE
  FU[I].Frei:=FALSE;
 END_IF;
END_FOR;
(* Aufteilung nur, wenn Gesamtsollwert innerhalb der zuvor bestimmten Grenzen *)
IF (PSoll>PMin) AND (PSoll<=PMax)
THEN
 (* FU-Sollwerte mit 0 vorbelegen *)
 FOR I:=0 TO 2 DO
  FU[I].PSoll:=0;
 END_FOR;
 (* Zu verteilende Leistung "PRest" mit Gesamtsollwert vorbelegen *)
 PRest:=PSoll;
 REPEAT
  (* Zu verteilende Leistung gleichmässig auf freie FUs aufteilen *)
  PSollProFU:=PRest/FreieFUs;
  FOR I:=0 TO 2 DO
   IF FU[I].Frei
   THEN
    FU[I].PSoll:=FU[I].PSoll+PSollProFU;
   END_IF;
  END_FOR;
  (* Grenzwertverletzungen korrigieren,
   überschüssige bzw. fehlende Leistung in "PRest" speichern *)
  PRest:=0;
  FOR I:=0 TO 2 DO
   IF FU[I].PSoll<FU[I].PMin
   THEN
    PRest:=PRest+FU[I].PSoll-FU[I].PMin;
    FU[I].PSoll:=FU[I].PMin;
    FU[I].Frei:=FALSE;
    FreieFUs:=FreieFUs-1;
   ELSIF FU[I].PSoll>FU[I].PMax
   THEN
    PRest:=PRest+FU[I].PSoll-FU[I].PMax;
    FU[I].PSoll:=FU[I].PMax;
    FU[I].Frei:=FALSE;
    FreieFUs:=FreieFUs-1;
   END_IF;
  END_FOR;
 (* bis PRest nahe 0 (wegen möglicher Real-Rundungsfehler) *)
 UNTIL ABS(PRest)<0.000001
 END_REPEAT;
END_IF;