Zuviel Werbung? - > Hier kostenlos beim SPS-Forum registrieren

Seite 3 von 5 ErsteErste 12345 LetzteLetzte
Ergebnis 21 bis 30 von 46

Thema: Probleme mit Zykluszeit

  1. #21
    Registriert seit
    07.03.2004
    Beiträge
    4.369
    Danke
    946
    Erhielt 1.158 Danke für 831 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von Steve81 Beitrag anzeigen
    ...
    also ich mache es in meinem Programm bereits so, dass ich nur bei den zulässiges Kombinationen was die Einzelwertmenge betrifft weiterrechne.
    Anzahl_p_P_min und Anzahl_p_P_max sind die min und max Stückzahl pro Packung. (z.B. 3 oder 2-4 Schnitzel pro 500g Pack)
    ...
    dann übergebe ich die Werte an den FC63 der mir den minimalen den maximalen und die Summe der Einzelwerte zurück liefert.
    ...
    Also ich denke eben das es nicht sinnvoll ist alle 2^20 Kombinationen überhaupt in betracht zu ziehen.
    Wenn Du jeden Wert darauf prüfst ob er nur aus z.B. 3 Bit besteht musst Du ja immer noch über eine Million Prüfungen machen.

    Ich würde nur die Kombinationen ansteuern die aus z.B. 3 Bit bestehen.

    Wenn man dann noch die Durchläufe auf mehrere SPS-Zyklen verteilt ist die Aufgabe schon gar nicht mehr so groß.

    Wenn die Werte nun noch sortiert vorhanden wären, wäre das ganze noch leicht zu optimieren. Aber das lasse ich hier mal außen vor da dies jetzt die Übersichtlichkeit nicht fördern würde.

    Ich habe das ganze mal für die Aufgabe 3 aus 20 (also 1140 Möglichkeiten) in CoDeSys Programmiert. Die Varianten 2 bzw. 4 aus 20 müssten da noch rein.

    Die Umsetzung von diesem ST-Code nach SCL sollte eigentlich nicht so schwer sein.

    Bei myDWORD_C.0 müsste eben ein Array über 20 BOOL mit dem AT auf das myDWORD_C gesetzt werden das man z.B. myDWORD_Array[0] schreiben kann. Da könnte man dann die IF-THEN-ELSE Batterie auch schnell noch durch eine FOR-Schleife ersetzen. (* Ich schweife ab ;o( *)

    So hier mal mein Code:

    Code:
    PROGRAM Opti
    VAR_INPUT
        ENABLE                :BOOL;
        Target              :REAL;
      ValueArray    :ARRAY[0..19] OF REAL;
    END_VAR
    
    VAR
        myENABLE            :BOOL;
        myOptimum            :REAL;
        myOptimumCom    :DWORD;
        myDWORD_1            :DWORD;
        myDWORD_2            :DWORD;
        myDWORD_3            :DWORD;
        myDWORD_C            :DWORD;
        myActual            :REAL;
        myRealArray     :ARRAY[0..19] OF REAL;
        myCount                :INT;
    END_VAR
    
    VAR_OUTPUT
        BUSY                    :BOOL;
        Optimum                :REAL;
        OptimumCom        :DWORD;
    END_VAR
    
    IF ENABLE AND NOT myENABLE THEN (* Eine positive Flanke am Enable dient als Startsignal *)
        (* Initialisierung  *)
      myRealArray  := ValueArray;
        myActual         := 0.0;
        myOptimum    := 0.0;
      myOptimumCom := 0;
        myDWORD_1    := 1; (* Kleinstwertige Variation von drei Bits *)
        myDWORD_2    := 2; (* " *)
        myDWORD_3    := 4; (* " *)
        BUSY         := TRUE;
        myCount      := 0;
    ELSIF BUSY THEN
    
        WHILE myCount <= 255 DO (* Schleife wie viele Durchläufe max. pro SPS Zyklus gemacht werden *)
    
            (* Kombiniertes DWORD erstellen *)
            myDWORD_C := myDWORD_1 OR myDWORD_2 OR myDWORD_3;
    
            (* Gewichtsberechnung der aktuellen Kombination *)
             myActual := 0.0;
            IF myDWORD_C.0  THEN myActual := myActual + myRealArray[ 0]; END_IF;
            IF myDWORD_C.1  THEN myActual := myActual + myRealArray[ 1]; END_IF;
            IF myDWORD_C.2  THEN myActual := myActual + myRealArray[ 2]; END_IF;
            IF myDWORD_C.3  THEN myActual := myActual + myRealArray[ 3]; END_IF;
            IF myDWORD_C.4  THEN myActual := myActual + myRealArray[ 4]; END_IF;
            IF myDWORD_C.5  THEN myActual := myActual + myRealArray[ 5]; END_IF;
            IF myDWORD_C.6  THEN myActual := myActual + myRealArray[ 6]; END_IF;
            IF myDWORD_C.7  THEN myActual := myActual + myRealArray[ 7]; END_IF;
            IF myDWORD_C.8  THEN myActual := myActual + myRealArray[ 8]; END_IF;
            IF myDWORD_C.9  THEN myActual := myActual + myRealArray[ 9]; END_IF;
            IF myDWORD_C.10 THEN myActual := myActual + myRealArray[10]; END_IF;
            IF myDWORD_C.11 THEN myActual := myActual + myRealArray[11]; END_IF;
            IF myDWORD_C.12 THEN myActual := myActual + myRealArray[12]; END_IF;
            IF myDWORD_C.13 THEN myActual := myActual + myRealArray[13]; END_IF;
            IF myDWORD_C.14 THEN myActual := myActual + myRealArray[14]; END_IF;
            IF myDWORD_C.15 THEN myActual := myActual + myRealArray[15]; END_IF;
            IF myDWORD_C.16 THEN myActual := myActual + myRealArray[16]; END_IF;
            IF myDWORD_C.17 THEN myActual := myActual + myRealArray[17]; END_IF;
            IF myDWORD_C.18 THEN myActual := myActual + myRealArray[18]; END_IF;
            IF myDWORD_C.19 THEN myActual := myActual + myRealArray[19]; END_IF;
    
            (* Kombination bewerten *)
            IF ABS(myActual - Target) < ABS(myOptimum - Target) THEN
                myOptimum := myActual;
                myOptimumCom := myDWORD_C;
            END_IF;
    
            IF myDWORD_C.19 AND myDWORD_C.18 AND  myDWORD_C.17 THEN (* Fertig *)
                Optimum    := myOptimum;
                OptimumCom := myOptimumCom;
                BUSY       := FALSE;
            ELSE
                IF myDWORD_C.19 AND myDWORD_C.18 THEN    (* Schiebe alle drei Bits *)
                    myDWORD_1 := SHL(myDWORD_1,1);
                    myDWORD_2 := SHL(myDWORD_1,1);
                    myDWORD_3 := SHL(myDWORD_2,1);
                ELSE
                    IF myDWORD_C.19 THEN (* Schiebe die zwei hochwertigen Bits *)
                        myDWORD_2 := SHL(myDWORD_2,1);
                        myDWORD_3 := SHL(myDWORD_2,1);
                    ELSE
                        myDWORD_3 := SHL(myDWORD_3,1); (* Schiebe nur das höchstwertige Bit *)
                    END_IF
                END_IF
            END_IF
            myCount := myCount + 1; (* Zähler zur Zyklus Verteilung inkrementieren *)
        END_WHILE;
        myCount := 0; (* Zähler zur Zyklus Verteilung nullen *)
    END_IF;
    
    myENABLE := ENABLE; (* Wert für Flankenerkennung *)
    Ich denke das dort schon die Grundlegenden Ideen ersichtlich sind.
    If you open your Mind too much, your Brain will fall out.

  2. Folgender Benutzer sagt Danke zu zotos für den nützlichen Beitrag:

    Steve81 (09.12.2007)

  3. #22
    Registriert seit
    07.03.2004
    Beiträge
    4.369
    Danke
    946
    Erhielt 1.158 Danke für 831 Beiträge

    Standard

    Da mich das Thema interessiert, habe ich noch den Code auf 2,3,4 Bits erweitert.

    Code:
    PROGRAM Opti
    VAR_INPUT
      ENABLE        :BOOL;
      Target        :REAL;
      ValueArray    :ARRAY[0..19] OF REAL;
    END_VAR
    
    VAR
      myENABLE      :BOOL;
      myOptimum     :REAL;
      myOptimumCom  :DWORD;
      myDWORD_1     :DWORD;
      myDWORD_2     :DWORD;
      myDWORD_3     :DWORD;
      myDWORD_4     :DWORD;
      myDWORD_C     :DWORD;
      myActual      :REAL;
      myRealArray   :ARRAY[0..19] OF REAL;
      myCount       :INT;
    END_VAR
    
    VAR_OUTPUT
      BUSY          :BOOL;
      Optimum       :REAL;
      OptimumCom    :DWORD;
    END_VAR
    
    IF ENABLE AND NOT myENABLE THEN (* Eine positive Flanke am Enable dient als Startsignal *)
      (* Initialisierung  *)
      myRealArray  := ValueArray;
      myActual     := 0.0;
      myOptimum    := 0.0;
      myOptimumCom := 0;
      myDWORD_1    := 0; (* Kleinstwertige Variation von zwei Bits *)
      myDWORD_2    := 0; (* " *)
      myDWORD_3    := 1; (* " *)
      myDWORD_4    := 2; (* " *)
      BUSY         := TRUE;
      myCount      := 0;
    ELSIF BUSY THEN
    
      WHILE myCount <= 512 AND BUSY DO (* Schleife wie viele Durchläufe max. pro SPS Zyklus gemacht werden *)
    
        (* Kombiniertes DWORD erstellen *)
        myDWORD_C := myDWORD_1 OR myDWORD_2 OR myDWORD_3 OR myDWORD_4;
    
        (* Gewichtsberechnung der aktuellen Kombination *)
         myActual := 0.0;
        IF myDWORD_C.0  THEN myActual := myActual + myRealArray[ 0]; END_IF;
        IF myDWORD_C.1  THEN myActual := myActual + myRealArray[ 1]; END_IF;
        IF myDWORD_C.2  THEN myActual := myActual + myRealArray[ 2]; END_IF;
        IF myDWORD_C.3  THEN myActual := myActual + myRealArray[ 3]; END_IF;
        IF myDWORD_C.4  THEN myActual := myActual + myRealArray[ 4]; END_IF;
        IF myDWORD_C.5  THEN myActual := myActual + myRealArray[ 5]; END_IF;
        IF myDWORD_C.6  THEN myActual := myActual + myRealArray[ 6]; END_IF;
        IF myDWORD_C.7  THEN myActual := myActual + myRealArray[ 7]; END_IF;
        IF myDWORD_C.8  THEN myActual := myActual + myRealArray[ 8]; END_IF;
        IF myDWORD_C.9  THEN myActual := myActual + myRealArray[ 9]; END_IF;
        IF myDWORD_C.10 THEN myActual := myActual + myRealArray[10]; END_IF;
        IF myDWORD_C.11 THEN myActual := myActual + myRealArray[11]; END_IF;
        IF myDWORD_C.12 THEN myActual := myActual + myRealArray[12]; END_IF;
        IF myDWORD_C.13 THEN myActual := myActual + myRealArray[13]; END_IF;
        IF myDWORD_C.14 THEN myActual := myActual + myRealArray[14]; END_IF;
        IF myDWORD_C.15 THEN myActual := myActual + myRealArray[15]; END_IF;
        IF myDWORD_C.16 THEN myActual := myActual + myRealArray[16]; END_IF;
        IF myDWORD_C.17 THEN myActual := myActual + myRealArray[17]; END_IF;
        IF myDWORD_C.18 THEN myActual := myActual + myRealArray[18]; END_IF;
        IF myDWORD_C.19 THEN myActual := myActual + myRealArray[19]; END_IF;
    
        (* Kombination bewerten *)
        IF ABS(myActual - Target) < ABS(myOptimum - Target) THEN
          myOptimum := myActual;
          myOptimumCom := myDWORD_C;
        END_IF;
    
        IF myDWORD_C.19 AND myDWORD_C.18 AND myDWORD_C.17 AND myDWORD_C.16 THEN (* Fertig *)
          Optimum    := myOptimum;
          OptimumCom := myOptimumCom;
          BUSY       := FALSE;
        ELSE
          IF myDWORD_C.19 AND myDWORD_C.18 AND myDWORD_C.17 THEN  (* Schiebe alle vier Bits *)
            IF myDWORD_1 = 0 THEN (* Übergang von 3 auf 4 Bit *)
              myDWORD_1 := 1;
            ELSE
              myDWORD_1 := SHL(myDWORD_1,1);
            END_IF;
    
            myDWORD_2 := SHL(myDWORD_1,1);
            myDWORD_3 := SHL(myDWORD_2,1);
            myDWORD_4 := SHL(myDWORD_3,1);
          ELSE
            IF myDWORD_C.19 AND myDWORD_C.18 THEN (* Schiebe die drei hochwertigen Bits *)
              IF myDWORD_2 = 0 THEN (* Übergang von 2 auf 3 Bit *)
                myDWORD_2 := 1;
              ELSE
                myDWORD_2 := SHL(myDWORD_2,1);
              END_IF;
    
              myDWORD_3 := SHL(myDWORD_2,1);
              myDWORD_4 := SHL(myDWORD_3,1);
            ELSE
              IF myDWORD_C.19 THEN (* Schiebe die zwei hochwertigen Bits *)
                myDWORD_3 := SHL(myDWORD_3,1);
                myDWORD_4 := SHL(myDWORD_3,1);
              ELSE
                myDWORD_4 := SHL(myDWORD_4,1); (* Schiebe nur das höchstwertige Bit *)
              END_IF
            END_IF
          END_IF
        END_IF
        myCount := myCount + 1; (* Zähler zur Zyklus Verteilung inkrementieren *)
      END_WHILE;
      myCount := 0; (* Zähler zur Zyklus Verteilung nullen *)
    END_IF;
    
    myENABLE := ENABLE; (* Wert für Flankenerkennung *)
    Kommst Du mit der Umsetzung nach SCL klar?
    If you open your Mind too much, your Brain will fall out.

  4. Folgender Benutzer sagt Danke zu zotos für den nützlichen Beitrag:

    Steve81 (09.12.2007)

  5. #23
    Registriert seit
    01.10.2007
    Ort
    Waiblingen
    Beiträge
    3.317
    Danke
    767
    Erhielt 536 Danke für 419 Beiträge

    Lächeln

    da ich ja unprofessioneller bin, hab ich das mal in Basic geklopft und auch gleich mal ne Simulation drübergelegt ...

    Code:
    0 REM BEGINN SPAGHETTICODE
    1 REM geschrieben fuer MS-DOS Q-Basic V1.1
    2 REM Quelle: Win98SE-Setup-Disk
    3 REM moegliche alternative Quellen: Win95, WinNT
    4 REM ich nutze Basic-Eigenschaft, dass variablen grundsaetzlich bei erstverwendung mit Null vorbelegt sind
    5 REM
    6 RANDOMIZE TIMER
    7 Sollgewicht% = 1000
    8 DIM produkt%(20): OPEN "report.txt" FOR OUTPUT AS #1
    9 REM
    10 FOR ablaufdauer% = 1 TO 1000: PRINT ablaufdauer%; : REM Maschinentest auf 1000 Zyklen begrenzen
    11 REM
    12 REM Behaelter vorbelegen bzw. nachfuellen
    13 REM *************************************
    14 REM
    20 FOR t% = 1 TO 20
    21 IF produkt%(t%) <> 0 THEN GOTO 29
    22 wert% = (RND + RND + RND) * 222: REM Zufall mit ein bisschen Struktur generieren
    23 IF wert% < 100 THEN GOTO 22
    24 IF wert% > 700 THEN GOTO 22
    25 produkt%(t%) = wert%
    29 NEXT t%
    100 REM
    101 REM Bubblesort - damit der Mensch schneller begreift, Maschine braucht keine Sortierung
    102 REM **********
    103 REM
    110 istsortiert% = 1
    112 FOR t% = 1 TO 19
    113 IF produkt%(t%) <= produkt%(t% + 1) THEN GOTO 115
    114 istsortiert% = 0: wert% = produkt%(t% + 1): produkt%(t% + 1) = produkt%(t%): produkt%(t%) = wert%
    115 NEXT t%
    118 IF istsortiert% = 0 THEN GOTO 110
    178 REM
    179 REM Vorbereitung der Suche
    180 zeiger1% = 0
    181 zeiger2% = 0
    182 zeiger3% = 0
    183 zeiger4% = 0
    184 besteSumme% = 32767
    200 REM
    201 REM beste Zweierkombination suchen
    202 FOR t% = 1 TO 19
    203 FOR i% = t% + 1 TO 20
    204 wert% = produkt%(t%) + produkt%(i%)
    205 IF wert% < Sollgewicht% OR wert% > besteSumme% GOTO 299
    206 zeiger1% = t%
    207 zeiger2% = i%
    208 besteSumme% = wert%
    299 NEXT i%: NEXT t%
    300 REM
    301 REM bessere Dreierkombination suchen
    302 FOR a% = 1 TO 18
    303 FOR b% = a% + 1 TO 19
    304 FOR c% = b% + 1 TO 20
    310 wert% = produkt%(a%) + produkt%(b%) + produkt%(c%)
    311 IF wert% < Sollgewicht% OR wert% > besteSumme% GOTO 399
    312 zeiger1% = a%
    313 zeiger2% = b%
    314 zeiger3% = c%
    320 besteSumme% = wert%
    399 NEXT c%: NEXT b%: NEXT a%
    400 REM
    401 REM noch bessere Viererkombination suchen
    402 FOR a% = 1 TO 17
    403 FOR b% = a% + 1 TO 18
    404 FOR c% = b% + 1 TO 19
    405 FOR d% = c% + 1 TO 20
    410 wert% = produkt%(a%) + produkt%(b%) + produkt%(c%) + produkt%(d%)
    411 IF wert% < Sollgewicht% OR wert% > besteSumme% GOTO 499
    412 zeiger1% = a%
    413 zeiger2% = b%
    414 zeiger3% = c%
    415 zeiger4% = d%
    420 besteSumme% = wert%
    499 NEXT d%: NEXT c%: NEXT b%: NEXT a%
    1000 REM so, jetzt ist der Suchalgorithmus vorbei, weiter mit Maschinensimulation und Report zur Analyse des Prozessverhaltens ...
    1100 FOR t% = 1 TO 20
    1101 PRINT #1, produkt%(t%);
    1102 NEXT t%
    1103 PRINT #1, "gewaehlt:";
    1104 IF zeiger1% <> 0 THEN PRINT #1, produkt%(zeiger1%);
    1105 IF zeiger2% <> 0 THEN PRINT #1, produkt%(zeiger2%);
    1106 IF zeiger3% <> 0 THEN PRINT #1, produkt%(zeiger3%);
    1107 IF zeiger4% <> 0 THEN PRINT #1, produkt%(zeiger4%);
    1108 PRINT #1, "gibt"; besteSumme%
    1200 REM naechster Durchlauf, dafuer verbrauchte Produkte loeschen
    1201 IF zeiger1% <> 0 THEN produkt%(zeiger1%) = 0
    1202 IF zeiger2% <> 0 THEN produkt%(zeiger2%) = 0
    1203 IF zeiger3% <> 0 THEN produkt%(zeiger3%) = 0
    1204 IF zeiger4% <> 0 THEN produkt%(zeiger4%) = 0
    9999 NEXT ablaufdauer%
    und dazu noch den Output, den der Algorithmus mitsamt seiner drübergelegten Maschinensimulation lieferte, siehe Anhang!

    ich will jetzt nicht behaupten, dass das absolut fehlerfrei ist - ich hab halt mal die Spaghetti gekocht, bis sie mir essbar schienen. Aber so könnte man, denke ich, das Problem lösen, ohne an absolute CPU-Leistungsgrenzen zu stoßen. Ich denke mal, der benutzte Algorithmus macht mal den Unterschied zwischen 319 und 317 aus.

    so, die Übersetzung davon nach SCL überlasse ich anderen - äh, Professionellen!

    Ich geb ja zu, als AWL-Progger hab ich da dann einiges mit Pointern zu hantieren, um das ohne SCL umzusetzen ... oder irgend ein Geniestreich mit sortierten Werten - egal - wollt ja mal die Richtung, ich muss ja nicht ins Ziel treffen

    Schöne Grüße!
    Angehängte Dateien Angehängte Dateien
    Zitieren Zitieren da auch mich das Thema interessiert, will ich auch noch mal ...  

  6. Folgender Benutzer sagt Danke zu Perfektionist für den nützlichen Beitrag:

    Steve81 (09.12.2007)

  7. #24
    Registriert seit
    01.10.2007
    Ort
    Waiblingen
    Beiträge
    3.317
    Danke
    767
    Erhielt 536 Danke für 419 Beiträge

    Standard

    ... o.k., was mir ergänzend nebenbei noch so auffällt: so ne dumme 317 ist weder in der Lage, ein Teilprozessabbild für einen Weckalarm zu generieren, so dass man den Weckalarm als zyklisches Programm missbrauchen könnte, noch ist Hintergrundbearbeitung bei ihr vorgesehen. Also muss man den von mir vorgeschlagenen Algorithmus auf irgend eine unkomfortable Art und Weise auf mehrere Zyklen aufteilen ...

    aber jetzt FEIERABEND!!! bis morgen ....

  8. #25
    Registriert seit
    07.03.2004
    Beiträge
    4.369
    Danke
    946
    Erhielt 1.158 Danke für 831 Beiträge

    Standard

    Ich habe mich gerade an die Umsetzung von CoDeSys-ST auf Step7-SCL gewagt.

    Also ich hänge gerade an der beschissenen Step7 Byte Anordnung. Damit quäle ich mich heute Abend nicht mehr.

    Gute Nacht!
    If you open your Mind too much, your Brain will fall out.

  9. #26
    Avatar von Steve81
    Steve81 ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    30.06.2007
    Ort
    In der Pfalz
    Beiträge
    503
    Danke
    72
    Erhielt 77 Danke für 65 Beiträge

    Standard

    Zitat Zitat von zotos Beitrag anzeigen
    Ich habe mich gerade an die Umsetzung von CoDeSys-ST auf Step7-SCL gewagt.

    Also ich hänge gerade an der beschissenen Step7 Byte Anordnung. Damit quäle ich mich heute Abend nicht mehr.

    Gute Nacht!
    Also ich komm heut Abend auch nicht mehr dazu aber hoffentlich morgen. Wobei es da auch eng wird, da ich geschätlich unterwegs bin.

    Werde mich mal nach einem Handbung für CoDeSys-ST umsehen (falls ich nichts finde könnt ihr mir bestimmt auch weiterhelfen) damit mir die Umsetzung auf S7-SCL leichter fällt.
    Danke nochmal für die Unterstützung, kann ich wirklich gut gebrauchen als "SCL-Anfänger".

  10. #27
    Registriert seit
    07.03.2004
    Beiträge
    4.369
    Danke
    946
    Erhielt 1.158 Danke für 831 Beiträge

    Standard

    Wie kann man sich das nur freiwillig zumuten? Siemens Byteverknotung am Morgen. Und wer jetzt kommt und diese Scheiß Siemens Byteanordnung noch gut heißt, der zählt zu dem Rudel hirnloser Irrer, die als erste an die Wand gestellt werden, wenn die Revolution kommt.

    So die Siemensianische Byteseuche ist bewältigt.

    Der Algorithmus kommt mit PLCsim auf meinem Rechner auch ca 240ms Wobei dies mit einer Zykluszeit von ca 20ms schon etwas an die Resourchen geht. Also wenn man die Abbruchbedingung der While-Schleife von 512 auf einen kleineren Wert setzt geht die Zykluszeit wieder runter dafür wird die Laufzeit der Algorithmus etwas größer. Das muss man aber wohl mit dem Rest des Programms auf der Realen Hardware Testen und dann schauen das man bei Lauf- und Zykluszeit nicht an die Grenze geht.
    Geändert von zotos (10.12.2007 um 11:59 Uhr)
    If you open your Mind too much, your Brain will fall out.

  11. #28
    Registriert seit
    07.03.2004
    Beiträge
    4.369
    Danke
    946
    Erhielt 1.158 Danke für 831 Beiträge

    Standard

    Also um die Funktionsweise dieses Algorithmus zu verstehen rate ich das den ST-Code oben zu lesen da hier im SCL Code keine Zuordnung der Bits mehr zu verstehen ist ohne laut zu fluchen.

    Hier die Siemens Bytewurschtelversion:
    Code:
    FUNCTION_BLOCK FB10
    VAR_INPUT
      ENABLE         :BOOL;
      Target         :REAL;
      IN_Real_01     :REAL;
      IN_Real_02     :REAL;
      IN_Real_03     :REAL;
      IN_Real_04     :REAL;
      IN_Real_05     :REAL;    
      IN_Real_06     :REAL;
      IN_Real_07     :REAL;
      IN_Real_08     :REAL;
      IN_Real_09     :REAL;
      IN_Real_10     :REAL;    
      IN_Real_11     :REAL;
      IN_Real_12     :REAL;
      IN_Real_13     :REAL;
      IN_Real_14     :REAL;
      IN_Real_15     :REAL;    
      IN_Real_16     :REAL;
      IN_Real_17     :REAL;
      IN_Real_18     :REAL;
      IN_Real_19     :REAL;
      IN_Real_20     :REAL;    
      
    END_VAR
    
    VAR
      myENABLE      :BOOL;
      myOptimum     :REAL;
      myOptimumCom  :DWORD;
      myOptimum_Array  AT myOptimumCom :ARRAY[0..31] OF BOOL;
      myDWORD_1     :DWORD;
      myDWORD_2     :DWORD;
      myDWORD_3     :DWORD;
      myDWORD_4     :DWORD;
      myDWORD_C     :DWORD;
      myDWORD_Array  AT myDWORD_C :ARRAY[0..31] OF BOOL;  
      myActual      :REAL;
      myRealArray   :ARRAY[0..31] OF REAL;
      
      myCount       :INT;
    END_VAR
    
    VAR_OUTPUT
      BUSY       :BOOL;
      Optimum    :REAL;
      OUT_01     :BOOL;
      OUT_02     :BOOL;
      OUT_03     :BOOL;
      OUT_04     :BOOL;
      OUT_05     :BOOL;
      OUT_06     :BOOL;
      OUT_07     :BOOL;
      OUT_08     :BOOL;
      OUT_09     :BOOL;
      OUT_10     :BOOL;
      OUT_11     :BOOL;
      OUT_12     :BOOL;
      OUT_13     :BOOL;
      OUT_14     :BOOL;
      OUT_15     :BOOL;
      OUT_16     :BOOL;
      OUT_17     :BOOL;
      OUT_18     :BOOL;
      OUT_19     :BOOL;
      OUT_20     :BOOL;
    END_VAR
    
    
    IF ENABLE AND NOT myENABLE THEN (* Eine positive Flanke am Enable dient als Startsignal *)
      (* Initialisierung  *)
      myActual     := 0.0;
      myOptimum    := 0.0;
      myOptimumCom := 0;
      myDWORD_1    := 0; (* Kleinstwertige Variation von zwei Bits *)
      myDWORD_2    := 0; (* " *)
      myDWORD_3    := 1; (* " *)
      myDWORD_4    := 2; (* " *)
      BUSY         := TRUE;
      myCount      := 0;
      myRealArray[ 0] := IN_Real_01; 
      myRealArray[ 1] := IN_Real_02; 
      myRealArray[ 2] := IN_Real_03; 
      myRealArray[ 3] := IN_Real_04; 
      myRealArray[ 4] := IN_Real_05; 
      myRealArray[ 5] := IN_Real_06; 
      myRealArray[ 6] := IN_Real_07; 
      myRealArray[ 7] := IN_Real_08; 
      myRealArray[ 8] := IN_Real_09; 
      myRealArray[ 9] := IN_Real_10; 
      myRealArray[10] := IN_Real_11; 
      myRealArray[11] := IN_Real_12; 
      myRealArray[12] := IN_Real_13; 
      myRealArray[13] := IN_Real_14; 
      myRealArray[14] := IN_Real_15; 
      myRealArray[15] := IN_Real_16; 
      myRealArray[16] := IN_Real_17; 
      myRealArray[17] := IN_Real_18; 
      myRealArray[18] := IN_Real_19; 
      myRealArray[19] := IN_Real_20;   
    ELSIF BUSY THEN
    
      WHILE myCount < 512 AND BUSY DO (* Schleife wie viele Durchläufe max. pro SPS Zyklus gemacht werden *)
    
        (* Kombiniertes DWORD erstellen *)
        myDWORD_C := myDWORD_1 OR myDWORD_2 OR myDWORD_3 OR myDWORD_4;
    
        (* Gewichtsberechnung der aktuellen Kombination *)
         myActual := 0.0;
        IF myDWORD_Array[24] THEN myActual := myActual + myRealArray[ 0]; END_IF;
        IF myDWORD_Array[25] THEN myActual := myActual + myRealArray[ 1]; END_IF;
        IF myDWORD_Array[26] THEN myActual := myActual + myRealArray[ 2]; END_IF;
        IF myDWORD_Array[27] THEN myActual := myActual + myRealArray[ 3]; END_IF;
        IF myDWORD_Array[28] THEN myActual := myActual + myRealArray[ 4]; END_IF;
        IF myDWORD_Array[29] THEN myActual := myActual + myRealArray[ 5]; END_IF;
        IF myDWORD_Array[30] THEN myActual := myActual + myRealArray[ 6]; END_IF;
        IF myDWORD_Array[31] THEN myActual := myActual + myRealArray[ 7]; END_IF;
        IF myDWORD_Array[16] THEN myActual := myActual + myRealArray[ 8]; END_IF;
        IF myDWORD_Array[17] THEN myActual := myActual + myRealArray[ 9]; END_IF;
        IF myDWORD_Array[18] THEN myActual := myActual + myRealArray[10]; END_IF;
        IF myDWORD_Array[19] THEN myActual := myActual + myRealArray[11]; END_IF;
        IF myDWORD_Array[20] THEN myActual := myActual + myRealArray[12]; END_IF;
        IF myDWORD_Array[21] THEN myActual := myActual + myRealArray[13]; END_IF;
        IF myDWORD_Array[22] THEN myActual := myActual + myRealArray[14]; END_IF;
        IF myDWORD_Array[23] THEN myActual := myActual + myRealArray[15]; END_IF;
        IF myDWORD_Array[ 8] THEN myActual := myActual + myRealArray[16]; END_IF;
        IF myDWORD_Array[ 9] THEN myActual := myActual + myRealArray[17]; END_IF;
        IF myDWORD_Array[10] THEN myActual := myActual + myRealArray[18]; END_IF;
        IF myDWORD_Array[11] THEN myActual := myActual + myRealArray[19]; END_IF;
        
        (* Kombination bewerten *)
        IF ABS(myActual - Target) < ABS(myOptimum - Target) THEN
          myOptimum := myActual;
          myOptimumCom := myDWORD_C;
        END_IF;
      
        (* Dank Siemens nicht mehr zu kapieren. Die 11,10,9,8 sind die hochwertigen Bits *)
    
        IF myDWORD_Array[11] AND myDWORD_Array[10] AND myDWORD_Array[9] AND myDWORD_Array[8] THEN (* Fertig *) 
          (* Ausgabe! *)
          Optimum    := myOptimum;
          BUSY       := FALSE;      
          OUT_01 := myOptimum_Array[24]; 
          OUT_02 := myOptimum_Array[25]; 
          OUT_03 := myOptimum_Array[26]; 
          OUT_04 := myOptimum_Array[27]; 
          OUT_05 := myOptimum_Array[28]; 
          OUT_06 := myOptimum_Array[29]; 
          OUT_07 := myOptimum_Array[30]; 
          OUT_08 := myOptimum_Array[31]; 
          OUT_09 := myOptimum_Array[16]; 
          OUT_10 := myOptimum_Array[17]; 
          OUT_11 := myOptimum_Array[18]; 
          OUT_12 := myOptimum_Array[19]; 
          OUT_13 := myOptimum_Array[20]; 
          OUT_14 := myOptimum_Array[21]; 
          OUT_15 := myOptimum_Array[22]; 
          OUT_16 := myOptimum_Array[23]; 
          OUT_17 := myOptimum_Array[ 8]; 
          OUT_18 := myOptimum_Array[ 9]; 
          OUT_19 := myOptimum_Array[10]; 
          OUT_20 := myOptimum_Array[11];             
        ELSE
          IF myDWORD_Array[11] AND myDWORD_Array[10] AND myDWORD_Array[9] THEN  (* Schiebe alle vier Bits *)
            IF myDWORD_1 = 0 THEN (* Übergang von 3 auf 4 Bit *)
              myDWORD_1 := 1;
            ELSE
              myDWORD_1 := SHL(IN:=myDWORD_1,N:=1);
            END_IF;
    
            myDWORD_2 := SHL(IN:=myDWORD_1,N:=1);
            myDWORD_3 := SHL(IN:=myDWORD_2,N:=1);
            myDWORD_4 := SHL(IN:=myDWORD_3,N:=1);
          ELSE
            IF myDWORD_Array[11] AND myDWORD_Array[10] THEN (* Schiebe die drei hochwertigen Bits *)
              IF myDWORD_2 = 0 THEN (* Übergang von 2 auf 3 Bit *)
                myDWORD_2 := 1;
              ELSE
                myDWORD_2 := SHL(IN:=myDWORD_2,N:=1);
              END_IF;
              myDWORD_3 := SHL(IN:=myDWORD_2,N:=1);
              myDWORD_4 := SHL(IN:=myDWORD_3,N:=1);
            ELSE
              IF myDWORD_Array[11] THEN (* Schiebe die zwei hochwertigen Bits *)
                myDWORD_3 := SHL(IN:=myDWORD_3,N:=1);
                myDWORD_4 := SHL(IN:=myDWORD_3,N:=1);
              ELSE
                myDWORD_4 := SHL(IN:=myDWORD_4,N:=1); (* Schiebe nur das höchstwertige Bit *)
              END_IF;
            END_IF;
          END_IF;
        END_IF;
        myCount := myCount + 1; (* Zähler zur Zyklus Verteilung inkrementieren *)
      END_WHILE;
      myCount := 0; (* Zähler zur Zyklus Verteilung nullen *)
    END_IF;
    
    myENABLE := ENABLE; (* Wert für Flankenerkennung *)
    
    END_FUNCTION_BLOCK
    If you open your Mind too much, your Brain will fall out.

  12. Folgender Benutzer sagt Danke zu zotos für den nützlichen Beitrag:

    Steve81 (10.12.2007)

  13. #29
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.727
    Danke
    398
    Erhielt 2.404 Danke für 2.002 Beiträge

    Standard

    Zitat Zitat von zotos Beitrag anzeigen
    Also um die Funktionsweise dieses Algorithmus zu verstehen rate ich das den ST-Code oben zu lesen da hier im SCL Code keine Zuordnung der Bits mehr zu verstehen ist ohne laut zu fluchen.
    @Zotos:
    Hast du in dem Zusammenhang mal den AT-Befehl erwogen ?
    Damit hättest du dir doch eine Zuordnung erzeugen können, die deiner Bit-Adressierung von ST entspricht ...

  14. #30
    Registriert seit
    07.03.2004
    Beiträge
    4.369
    Danke
    946
    Erhielt 1.158 Danke für 831 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Zitat Zitat von Larry Laffer Beitrag anzeigen
    @Zotos:
    Hast du in dem Zusammenhang mal den AT-Befehl erwogen ?
    Damit hättest du dir doch eine Zuordnung erzeugen können, die deiner Bit-Adressierung von ST entspricht ...
    Hast Du Dir mal meinen SCL Code Angeschaut da sind AT-Befehle drin und das ist KEINESWEGS so wie in ST.

    Hier was zum Hirnverknoten:

    Code:
    OUT_01 := myOptimum_Array[24];
    OUT_02 := myOptimum_Array[25];
    OUT_03 := myOptimum_Array[26];
    OUT_04 := myOptimum_Array[27];
    OUT_05 := myOptimum_Array[28];
    OUT_06 := myOptimum_Array[29];
    OUT_07 := myOptimum_Array[30];
    OUT_08 := myOptimum_Array[31];
    OUT_09 := myOptimum_Array[16];
    OUT_10 := myOptimum_Array[17];
    OUT_11 := myOptimum_Array[18];
    OUT_12 := myOptimum_Array[19];
    OUT_13 := myOptimum_Array[20];
    OUT_14 := myOptimum_Array[21];
    OUT_15 := myOptimum_Array[22];
    OUT_16 := myOptimum_Array[23];
    OUT_17 := myOptimum_Array[ 8];
    OUT_18 := myOptimum_Array[ 9];
    OUT_19 := myOptimum_Array[10];
    OUT_20 := myOptimum_Array[11];
    Angehängte Dateien Angehängte Dateien
    If you open your Mind too much, your Brain will fall out.

Ähnliche Themen

  1. Zykluszeit
    Von Maurice im Forum CODESYS und IEC61131
    Antworten: 3
    Letzter Beitrag: 17.09.2011, 15:19
  2. Zykluszeit S7-200
    Von pinolino im Forum Simatic
    Antworten: 8
    Letzter Beitrag: 14.01.2009, 07:27
  3. Zusammenhang Zykluszeit Profibus Zykluszeit SPS
    Von Peltzerserbe im Forum Feldbusse
    Antworten: 1
    Letzter Beitrag: 28.04.2008, 22:09
  4. S7-317 2-DP Zykluszeit
    Von gustave im Forum Simatic
    Antworten: 6
    Letzter Beitrag: 23.06.2007, 10:19
  5. Zykluszeit bei OB`s
    Von slaesh im Forum Simatic
    Antworten: 3
    Letzter Beitrag: 25.10.2005, 18:00

Lesezeichen

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •