aus 6 Real Zahlen die höchste und die niedrigste ermitteln

spunky · 17 Juli 2007

Hallo,

Hab da ein kleines Problem, ich möchte 6 Real Zahlen vergleichen und die höchste / niedrigste Zahl ermitteln.

Am Ende soll das für eine Windenüberwachung dienen. Also Positionen (umdrehung der einzelnen Winde wird gezählt 6 Winden ingesamt). Die Winden sollen sich annähernd gleich schnell bewegen (Tolereanz 10 Impulse). Das heisst das die schnellste Winde abgestoppt werden soll, bis die langsamste Winde wieder aufgeholt hat.

Meine Lösung gefällt mir da nicht so sehr, aber hier tummeln sich ja ne Menge "schlauer" Köpfe herum.

L (Wert Winde 1)
L (Wert Winde 2)
> R
L (Wert Winde 1)
spb next2
spa nix2
next2: t DBx.DBDx (DB.Real Anzahl Umdrehung + Kennung Winde 1)
spa next
nix2: t DBx.DBDx (DB.Real Anzahl Umdrehung + Kennung Winde 2)
next:
L (DBx.DBDx)
L (Wert Winde 3)
>R
L (Wert Winde 3)
spb next3
spa nix3
next2: t DBx.DBDx (DB.Real Anzahl Umdrehung + Kennung Winde 3)
spa next
nix2: t DBx.DBDx (DB.Real Anzahl Umdrehung + Kennung Winde 1/2)
next:
usw.
das selbe noch für die kleinste Zahl

ich denk mal ein bissel kompliziert wie ich da ran gehe.

Helft mir da mal mit was Schicken auf die Sprünge.

Danke

CPU 315 2DP Soft Step7 5.4

borromeus · 17 Juli 2007

Vorher sortieren-> BubbleSort-> dann ersten und letzen nehmen.

spunky · 17 Juli 2007

ähm was meinste mit "Bubble Sort" ??

Kai · 17 Juli 2007

http://de.wikipedia.org/wiki/Bubblesort

https://www.sps-forum.de/threads/12657

Gruß Kai

spunky · 17 Juli 2007

erst mal danke !!!

muss ich morgen gleich mal testen.

Zottel · 18 Juli 2007

Bubblesort funktioniert natürlich, ist aber etwas aufwendig ((6-1)*6=30 Vergleiche) für so eine "kleine" Aufgabe. So geht es einfacher:
max=Wert[1]
min=Wert[1]
for i=2 to 6 do begin
if Wert>max then max=Wert
if Wert<min then min=Wert
end
Wenn man statt der Schleife einzelne Vergleiche programmiert, sieht es ähnlich wie dein AWL aus. Die kürzeste Version entsteht, wenn man es sich zunutze macht, daß der erste Wert im Akku verbleibt:
L #Wert1
L #Wert2
>R
SPB keinTausch1
TAK //tausche Akku1 und 2, also Wert1 wieder im Akku1
keinTausch1: L #Wert3
>R
SPB keinTausch2
TAK
keinTausch2: L #Wert4
>R
SPB keinTausch3
// usw.

Kai · 18 Juli 2007

spunky schrieb:
Hab da ein kleines Problem, ich möchte 6 Real Zahlen vergleichen und die höchste / niedrigste Zahl ermitteln.

Hier mal ein kurzes Programmbeispiel mit Bubblesort:

Code:

// FC100 : Bubblesort
 
// Datenbaustein öffnen
 
      AUF   DB   100
 
 
// Datensatz kopieren
 
      CALL  SFC   20
       SRCBLK :=P#DB100.DBX0.0 BYTE 36
       RET_VAL:=#BLKMOV_RET_VAR
       DSTBLK :=P#DB100.DBX36.0 BYTE 36
 
 
// Bubblesort
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     5
M01:  T     #ZAEHLER_01
 
      L     #ZAEHLER_01
M02:  T     #ZAEHLER_02
 
      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPB   M03
      SPA   M04
M03:  L     DBD [AR1,P#0.0]             // Wert 1
      T     DBD   72                    // Wert 7
 
      L     DBW [AR1,P#4.0]             // Kennung 1
      T     DBW   76                    // Kennung 7
 
      L     DBD [AR1,P#6.0]             // Wert 2
      T     DBD [AR1,P#0.0]             // Wert 1
 
      L     DBW [AR1,P#10.0]            // Kennung 2
      T     DBW [AR1,P#4.0]             // Kennung 1
 
      L     DBD   72                    // Wert 7
      T     DBD [AR1,P#6.0]             // Wert 2
 
      L     DBW   76                    // Kennung 7
      T     DBW [AR1,P#10.0]            // Kennung 2
 
M04:  L     P#6.0                       // Zeiger Wert 1 + 1
      +AR1  
 
      L     #ZAEHLER_02
      LOOP  M02
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     #ZAEHLER_01
      LOOP  M01

Gruß Kai

borromeus · 18 Juli 2007

Fast nicht verbesserbar!

Kai · 19 Juli 2007

borromeus schrieb:
Fast nicht verbesserbar!

Hier noch eine leicht verbesserte Programmversion. :-D

Code:

// FC100 : Bubblesort
 
// Datenbaustein öffnen
 
      AUF   DB   100
 
 
// Datensatz kopieren
 
      CALL  SFC   20
       SRCBLK :=P#DB100.DBX0.0 BYTE 36
       RET_VAL:=#BLKMOV_RET_VAR
       DSTBLK :=P#DB100.DBX36.0 BYTE 36
 
 
// Bubblesort
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     5
M01:  T     #ZAEHLER_01
 
      L     #ZAEHLER_01
M02:  T     #ZAEHLER_02
 
      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPB   M03
      SPA   M04
M03:  L     DBD [AR1,P#0.0]             // Wert 1 
      L     DBD [AR1,P#6.0]             // Wert 2  
      T     DBD [AR1,P#0.0]             // Wert 2 => Wert 1
      TAK   
      T     DBD [AR1,P#6.0]             // Wert 1 => Wert 2
 
      L     DBW [AR1,P#4.0]             // Kennung 1
      L     DBW [AR1,P#10.0]            // Kennung 2
      T     DBW [AR1,P#4.0]             // Kennung 2 => Kennung 1
      TAK   
      T     DBW [AR1,P#10.0]            // Kennung 1 => Kennung 2
 
M04:  L     P#6.0                       // Zeiger Wert 1 + 1
      +AR1  
 
      L     #ZAEHLER_02
      LOOP  M02
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     #ZAEHLER_01
      LOOP  M01

Gruß Kai

zotos · 19 Juli 2007

Code:

// FC100 : Bubblesort
 
// Datenbaustein öffnen
 
      AUF   DB   100
 
 
// Datensatz kopieren
 
      CALL  SFC   20
       SRCBLK :=P#DB100.DBX0.0 BYTE 36
       RET_VAL:=#BLKMOV_RET_VAR
       DSTBLK :=P#DB100.DBX36.0 BYTE 36
 
 
// Bubblesort
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     5
M01:  T     #ZAEHLER_01
 
M02:  T     #ZAEHLER_02
 
      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPBN  M04
      L     DBD [AR1,P#0.0]             // Wert 1 
      L     DBD [AR1,P#6.0]             // Wert 2  
      T     DBD [AR1,P#0.0]             // Wert 2 => Wert 1
      TAK   
      T     DBD [AR1,P#6.0]             // Wert 1 => Wert 2
 
      L     DBW [AR1,P#4.0]             // Kennung 1
      L     DBW [AR1,P#10.0]            // Kennung 2
      T     DBW [AR1,P#4.0]             // Kennung 2 => Kennung 1
      TAK   
      T     DBW [AR1,P#10.0]            // Kennung 1 => Kennung 2
 
M04:  L     P#6.0                       // Zeiger Wert 1 + 1
      +AR1  
 
      L     #ZAEHLER_02
      LOOP  M02
 
      L     P#36.0                      // Zeiger Wert 1
      LAR1  
 
      L     #ZAEHLER_01
      LOOP  M01

Kai · 19 Juli 2007

Hier noch einmal die Änderung von Zotos an meinem Programmcode:

Code:

      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPB   M03
      SPA   M04

Code:

      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPBN  M04

Gruß Kai

Kai · 19 Juli 2007

Zottel schrieb:
Bubblesort funktioniert natürlich, ist aber etwas aufwendig ((6-1)*6=30 Vergleiche) für so eine "kleine" Aufgabe.

Das ist so nicht ganz richtig.

Bubblesort benötigt zum Sortieren einer Datenfolge der Länge n folgende Anzahl von Vergleichen:

Code:

                              n * (n - 1)
(n - 1) + (n - 2) + ... + 1 = -----------
                                   2

Bei einer Datenfolge von 6 Zahlen

benötigt Bubblesort also 5 Durchläufe (n - 1) mit insgesamt 15 Vergleichen (n * (n - 1) / 2).

Durchlauf 1 = 6 - 1 = 5 Vergleiche

Durchlauf 2 = 6 - 2 = 4 Vergleiche

Durchlauf 3 = 6 - 3 = 3 Vergleiche

Durchlauf 4 = 6 - 4 = 2 Vergleiche

Durchlauf 5 = 6 - 5 = 1 Vergleich

Summe = 15 Vergleiche

Gruß Kai

spunky · 19 Juli 2007

Hallo,

hier mal an alle ein DICKES DANKE !!!

man oh man, geniale sache, genau das was ich gebraucht habe.

hugo · 21 Juli 2007

schau mal in die open source library von oscat rein dort ist bubble sort und auch array min und array max im source code vorhanden
wenn du forlaufend aus einem array min und max werte benötigst solltest du nicht unbedingt bubble sort anwenden, das ist viel zu aufwendig weil zuviele tauschvorgänge.
um min und max zu ermitteln must du nur einmnal das array durchlaufen und hast das ergebnis.
siehe hierzu die fumktionen array_min und array_max
den source code findest du unter www.oscat.de

cosmo · 15 August 2008

moin,
von mir auch schon mal ein dickes danke, der algorithmus hat mir auch schon sehr geholfen und stehe grad auch noch in den anfängen, und versuche mich in awl einzuarbeiten, und hab auch bislang nur grob mit pointern zu tun gehabt, aber stimmt es, wenn ich jetzt 7 statt 6 zahlen miteinander vergleichen will, ich nur überall wo 36.0 steht, 40.0 schreiben muss, oder müsste noch mehr geändert werden?

SPSKILLER · 15 August 2008

Hallo,

folgendes sollte einfacher sein (AWL-Quelle):

Code:

FUNCTION "SORT_MAX_REAL" : VOID
TITLE =Sortieralgorithmus nach größtem Wert [REAL]
AUTHOR : Micha
FAMILY : SORT
NAME : MAX_REAL
VERSION : 1.2
 
VAR_INPUT
  DB_NR : BLOCK_DB ; 
  ANZ : INT ; 
END_VAR
VAR_TEMP
  tiLC : INT ; //Loopcounter
  tbFertig : BOOL ; 
END_VAR
BEGIN
NETWORK
TITLE =Algorithmus
//
//
      AUF   #DB_NR; 
NEU:  LAR1  P#DBX 0.0; 
      S     #tbFertig; 
      L     #ANZ; 
      DEC   1; 
L1:   T     #tiLC; 
      L     D [AR1,P#0.0]; 
      L     D [AR1,P#4.0]; 
      >=R   ; 
      SPB   KSOR; 
      L     D [AR1,P#0.0]; 
      L     D [AR1,P#4.0]; 
      T     D [AR1,P#0.0]; 
      TAK;
      T     D [AR1,P#4.0]; 
      SET   ; 
      R     #tbFertig; 
KSOR: +AR1  P#4.0; 
      L     #tiLC; 
      LOOP  L1; 
      UN    #tbFertig; 
      SPB   NEU; 
END_FUNCTION

Es muss noch ein DB, der mindestens die Anzahl der am INT-Eingang angegebenen Real-Werte enthält, verschaltet werden.
Nach Bearbeitung des FCs stehen die 6 Werte sortiert im angegebenen DB.

Ich habe keine Auswertung der Parametrierung reinprogrammiert!
Bei Parametrierfehler (z.B. 8 am INT-Eingang, aber nur 6 Real Werte im DB, oder falscher DB) gibts Bereichslängenfehler, und ggf. CPU-Stopp!

Gruß Micha

Kai · 15 August 2008

cosmo schrieb:
stimmt es, wenn ich jetzt 7 statt 6 zahlen miteinander vergleichen will, ich nur überall wo 36.0 steht, 40.0 schreiben muss, oder müsste noch mehr geändert werden?

Hier noch mal ein kurzes Programmbeispiel für die Sortierung von 7 REAL-Zahlen mit Bubblesort:

Code:

// FC100 : Bubblesort
 
// Datensatz kopieren
 
      CALL  SFC   20
       SRCBLK :=[COLOR=red]P#DB100.DBX0.0 BYTE 42[/COLOR]
       RET_VAL:=#BLKMOV_RET_VAR
       DSTBLK :=[COLOR=red]P#DB100.DBX42.0 BYTE 42[/COLOR]
 
// Bubblesort
 
      AUF   DB   100                    // Datenbaustein öffnen
 
      [COLOR=red]L     6[/COLOR]
M01:  T     #ZAEHLER_01
 
      [COLOR=red]L     P#42.0[/COLOR]                      // Zeiger Wert 1
      LAR1  
 
      L     #ZAEHLER_01
M02:  T     #ZAEHLER_02
 
      L     DBD [AR1,P#6.0]             // Wert 2
      L     DBD [AR1,P#0.0]             // Wert 1
      >R    
      SPBN  M03
      L     DBD [AR1,P#0.0]             // Wert 1 
      L     DBD [AR1,P#6.0]             // Wert 2  
      T     DBD [AR1,P#0.0]             // Wert 2 => Wert 1
      TAK   
      T     DBD [AR1,P#6.0]             // Wert 1 => Wert 2
 
      L     DBW [AR1,P#4.0]             // Kennung 1
      L     DBW [AR1,P#10.0]            // Kennung 2
      T     DBW [AR1,P#4.0]             // Kennung 2 => Kennung 1
      TAK   
      T     DBW [AR1,P#10.0]            // Kennung 1 => Kennung 2
 
M03:  L     P#6.0                       // Zeiger Wert 1 + 1
      +AR1  
 
      L     #ZAEHLER_02
      LOOP  M02
 
      L     #ZAEHLER_01
      LOOP  M01

Gruß Kai

volker · 15 August 2008

ohne jetzt mal auf den sinn einer vorigen sortierung einzugehen nur um min/max zu bestimmen, guckst du mal hier

http://lischis-home.dyndns.org/files/SPS/S7_Bausteine/dirindex.php
dort db_auswerten.zip

cosmo · 18 August 2008

ja danke schön, ich denk mal damit sollte ich es hinbekommen.
aber der sinn des ganzen ist, beispielsweise 6 pumpen entsprechend nach ihrer laufzeit zu sortieren, um die pumpen mit der geringsten laufzeit als erstes freizugeben, um den verschleiß möglichst konstant zu halten

volker · 18 August 2008

also doch sortieren. hast du anfangs aber nicht erwähnt.

die andere sachen ist die. wenn du deine pumpen immer so einschaltest, das alle in etwa die gleiche laufzeit haben, werden auch alle ungefähr gleichzeitig kaputt gehen.
ich würde die pumpen normal laufen lassen. hat nun eine pumpe wartungszeit überschritten, kann diese getauscht/gewartet werden und du hast trotzdem noch pumpen die sicher laufen.
wieviele pumpen wann laufen weiss ich ja in deinem fall nicht.

aus 6 Real Zahlen die höchste und die niedrigste ermitteln

Level-1

Level-3

Level-1

Level-1

Level-1

Level-3

Level-1

Anhänge

Level-3

Level-1

Anhänge

User des Jahres 2007

Level-1

Level-1

Level-1

Level-1

Level-1

Level-2

Level-1

Anhänge

Supermoderator

Level-1

Supermoderator

Similar threads

Wir schützen deine Privatsphäre