Step 7 Bitmusterüberprüfung mittels Schleife in AWL

Rune17

Level-1
Beiträge
11
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo zusammen,
ich bin ziemlich neu im Forum und habe ein Problem da ich nicht jeden Tag programmiere.
Ich möchte gerne mittels einer Schleife in AWL nicht in SCL (bei uns nicht zugelassen), oder brauch ich mehr Schleifen
folgendes machen!!
Ich möchte in einem DB100 dort sind Bitmuster eingetragen 64 Stück, Bitmuster sind immer 10 Byte lang die einzelnen Bitmuster mit einer Schleife miteinander vergleichen.
Das heißt Bitmuster 1 mit 2, dann 1 mit 3, usw....
2. Durchlauf muss ja die Startadresse um 10 Byte verschoben werden, dann vergleich Bitmuster 2 mit 3, dann 2 mit 4 , usw... bis 64.

Werden 2 gleiche Bitmuster gefunden muss eine Meldung abgesetzt werden und die schleife beendet werden.
Bei Ungleichheit müssen alle Bitmuster geprüft werden und dann die schleife verlassen bzw. normal beendet werden.

wie programmiere ich so etwas???

Danke schon mal für eure Hilfe.
Gruß Rune17
 
Ohne mir jetzt viele Gedanken nach einer optimalen Lösung zu machen... simpel, geradeaus, könnte so aussehen...
Code:
L     1                           //Schleifenzähler initialisieren
      T     #Index_VBasis
      L     2
      T     #Index_VWert

      SET   
      R     #bEqual

Mx10: L     #Index_VBasis               //Äußere Schleife - Vergleichsbasis
      +     -1                          //Startadresse der jeweiligen 10Byte
      L     10
      *I    
      SLD   3
      LAR1  

       AUF   "DbBitM"                    //10Byte der jeweilgen Vergleichsbasis nach Temp
      L     DBD [AR1,P#0.0]
      T     #CMP_A_DW1
      L     DBD [AR1,P#4.0]
      T     #CMP_A_DW2
      L     DBW [AR1,P#8.0]
      T     #CMP_A_W

Mx20: L     #Index_VWert                //Innere Schleife - Vergleichswert
      +     -1                          //Startadresse der jeweiligen 10Byte
      L     10
      *I    
      SLD   3
      LAR1  

       AUF   "DbBitM"                    //10Byte des jeweilgen Vergleichswerts nach Temp
      L     DBD [AR1,P#0.0]
      T     #CMP_B_DW1
      L     DBD [AR1,P#4.0]
      T     #CMP_B_DW2
      L     DBW [AR1,P#8.0]
      T     #CMP_B_W

       L     #CMP_A_DW1                  //Sonderfall ausschließen wenn alle Bits 0 sind (DB leer) - optional
      L     L#0
      ==D   
      U(    
      L     #CMP_A_DW2
      L     L#0
      ==D   
      )     
      U(    
      L     #CMP_A_W
      L     0
      ==I   
      )     
      SPB   Mx30

      L     #CMP_A_DW1                  //Vergleiche Bitmuster
      L     #CMP_B_DW1
      ==D   
      U(    
      L     #CMP_A_DW2
      L     #CMP_B_DW2
      ==D   
      )     
      U(    
      L     #CMP_A_W
      L     #CMP_B_W
      ==I   
      )     
      S     #bEqual                     //Setze Flag wenn gleich

      U     #bEqual                     //Gleich -Ergebnisse sichern und Schleife verlassen
      SPBN  Mx30

      L     #Index_VBasis               //Nummen der Bitmuster sichern die gleich waren
      T     #IndexEqual_1
      L     #Index_VWert
      T     #IndexEqual_2
      SPB   Mx99                        //Exit

Mx30: L     #Index_VWert                //Ungleich - Index Vergleichswert erhöhen
      +     1
      T     #Index_VWert

      L     #Index_VWert                //Alle Vergleichswerte durchlaufen? Nein -> Rücksprung
      L     64
      <=I   
      SPB   Mx20

      L     #Index_VBasis               //Alle Vergleichswerte durchlaufen? Ja
      +     1                           //Index Vergleichsbasis erhöhen auf Wert n
      T     #Index_VBasis
      +     1                           //Index Vergleichswert setzen auf n+1
      T     #Index_VWert

       L     #Index_VBasis               //Alle Vergleichsbasis-Werte geprüft? Nein -> Rücksprung
      L     63
      <=I   
      SPB   Mx10

Mx99: NOP   0
Da fehlen aber ein paar Dinge...
  1. Offsetbeginn der Adressen. Sollten die Bitmuster im DB100 nicht bei Adresse 0 beginnen.
  2. Eventuelle Sicherheitsprüfungen
  3. Variable Gestaltung der Bitmuster-Anzahl und Länge
... könnte man aber noch dazu bauen.

Als Anhaltspunkt kannst sollte es aber passen.

[EDIT] Wie Harald unten natürlich richtig angemerkt hat, ist das nicht sonderlich effizient. Ner S7315PN/DP kostest das schon 9,5-10ms wenn sie den komplette Durchlauf machen muss. :)
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich weiß ja nicht, ob diese Aufgabe in einer SPS gut aufgehoben ist oder ob das vielleicht nur eine reine Übungs-Aufgabe ist.
Wieviel Zeit hat die SPS für den Vergleich?
Mit welcher SPS soll diese Aufgabe gelöst werden?

Bei völlig unsortierten Bitmustern sind das im ungünstigsten Fall mehr als 2000 * 3 Vergleiche welche mehr als 40kB Daten bewegen - das würde ich nicht in eine einfache Schleife "über alles" legen! Da muß noch kräftig optimiert werden:
- Bitmuster sortiert eintragen bzw. Sortier-Index möglich?
- Schleife aufteilen in mehrere Durchläufe
- vorzeitige Abbrüche der Vergleiche einbauen
- ...?

Harald
 
Guten Morgen zusammen!

Mal eine Frage:
Wo kommen die Bitmuster her? Von einem Scanner o. Ä.?
Können die Muster dann nicht beim Eintragen in den DB verglichen werden?
a) Brauche ich dann nur einmal durchlaufen und das Neue mit den bereits Eingetragenen vergleichen.
b) Braucht der Vergleich nicht in jedem Zyklus stattfinden, sondern nur, wenn ein neues Bitmuster kommt.
Denn ich sehe das ähnlich wie Harald, das sind schon große Datenmengen, wo sich eine CPU lange dran aufhält...
Sonst kann man auch zumindest wortweise vergleichen und man muß dann ja auch nicht jedes Wort vergleichen: Wenn bereits der erste Vergleich fehlschlägt, kann man zum nächsten Bitmuster wechseln. Da brauche ich der CPU nicht zumuten, 10 Byte zu vergleichen, wenn bereits das erste Bit unterschiedlich ist.
So als Ideen....

Gruß
JS
 
Hallo JS,
die Bitmuster werden von Hand eingetragen.
es soll nur einmal eine Überprüfung statt finden ob 2 bitmuster sich gleichen, wenn ja meldung absetzen und prüfung beenden.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Ronin,
hier mal auszüge von meinem programm:
Die SPS steigt nach einiger zeit mit doppelwortzugriff aus., geht in stop.
Ich habe mal die Adressen und DB dazu geschrieben.
Ich bitte um weitere Hilfe.
Schleife soll 64 mal durchlaufen werden, kann ich aber erst mal auf 5 reduzieren um zu testen.
Schaut euch da programm mal an, bitte!

Deklaration der Variablen im FC:
Die Variablen sind im TEMP Verzeichnis wie folgt deklariert:

Index_VBasis = Int
Index_VWert = Int
CMP_A_DW1 = DWORD
CMP_A_DW2 = DWORD
CMP_B_DW1 = DWORD
CMP_B_DW2 = DWORD
CMP_A_W = DWORD
CMP_B_W = DWORD
IndexEqal_1 = DWORD
IndexEqal_2 = DWORD


Hier der DB dazu erste Adresse zum Prüfen ist ab DBX 1274.0 bis DBX1277.7
2. Adresse geht los ab DBX 1284.0 bis 1287.7 ( Bereich immer gleich 64 mal).

Typ[1].Typ_Variante[1] CHAR ' ' 'S' !* z.B. "X156, S176, N242, T246"
Typ[1].Typ_Variante[2] CHAR ' ' '1'
Typ[1].Typ_Variante[3] CHAR ' ' '7'
Typ[1].Typ_Variante[4] CHAR ' ' '6'
Typ[1].Typnummer INT 0 18 *! Typnummer 1 bis 255
Startadresse1: DBX 1274.0
Typ[1].Vorwahl_Bit_01 BOOL FALSE TRUE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_02 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_03 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_04 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_05 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_06 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_07 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_08 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_09 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_10 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_11 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_12 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_13 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_14 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_15 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_16 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_17 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_18 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_19 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_20 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_21 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_22 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_23 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_24 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_25 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_26 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_27 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_28 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_29 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_30 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_31 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_32 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Endadresse1: DBX1277.7
Typ[2].Typ_Variante[1] CHAR ' ' 'T' !* z.B. "X156, S176, N242, T246"
Typ[2].Typ_Variante[2] CHAR ' ' '2'
Typ[2].Typ_Variante[3] CHAR ' ' '4'
Typ[2].Typ_Variante[4] CHAR ' ' '6'
Typ[2].Typnummer INT 0 17 *! Typnummer 1 bis 255
Startadresse2: DBX 1284.0
Typ[2].Vorwahl_Bit_01 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_02 BOOL FALSE TRUE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_03 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_04 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_05 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_06 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_07 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_08 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_09 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_10 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_11 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_12 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_13 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_14 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_15 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_16 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_17 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_18 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_19 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_20 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_21 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_22 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_23 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_24 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_25 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_26 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_27 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_28 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_29 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_30 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_31 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_32 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Endadresse2: DBX1287.7

Usw…. 64 mal gleich aufgebaut!!!!


Hier die Programmierung der Schleifen
Netzwerk im FC:

L 1 // Init Schleife
T #Index_VBasis // Basiswert Schleife
L 2
T #Index_VWert // Wert Schleife veränderbar
//**********************************************************************************
SET
R "FGDB_Typzuordung".XM_0 // Meldung bei Bitmuster gleich
//**********************************************************************************

MX10: L #Index_VBasis // Anfangswert laden in AR1
L 1274 // Startadresse ersten der 10 Byte
*I
SLD 3
LAR1
//**********************************************************************************

AUF #FGDB //Bitmuster1 einlesen
L DBD [AR1,P#0.0]
T #CMP_A_DW1
L DBD [AR1,P#4.0]
T #CMP_A_DW2
L DBD [AR1,P#8.0]
T #CMP_A_W
//**********************************************************************************

MX20: L #Index_VWert // 2.Wert laden in AR1
L 1284 // Startadresse der zweiten 10 Byte
*I
SLD 3
LAR1
//**********************************************************************************

AUF #FGDB // Bitmuster2 einlesen
L DBD [AR1,P#0.0]
T #CMP_B_DW1
L DBD [AR1,P#4.0]
T #CMP_B_DW2
L DBD [AR1,P#8.0]
T #CMP_B_W
//**********************************************************************************

L #CMP_A_DW1 // Bitmuster vergleichen
L #CMP_B_DW1
==D
U(
L #CMP_A_DW2
L #CMP_B_DW2
==D
)
U(
L #CMP_A_W
L #CMP_B_W
==D
)
S "FGDB_Typzuordung".XM_0 // Setze Meldung wenn Bitmuster gleich
U "FGDB_Typzuordung".XM_0 // Wenn gleich dann sichern und Ende
SPBN MX30
L #Index_VBasis
T #IndexEqual_1
//**********************************************************************************
L #Index_VWert
T #IndexEqual_2
SPB MX99 //Exit Schleife
//**********************************************************************************

MX30: L #Index_VWert // Bei Ungleich Index VWert erhöhen
L 1
+I
L #Index_VWert

L #Index_VWert // Alle Werte durchlaufen? Nein
L 64 // Rücksprung
<=I
SPB MX20
//**********************************************************************************

L #Index_VBasis // Alle Werte durchlaufen ? Ja
L 1 // Index erhöhen auf Wert n
+I
T #Index_VBasis
L 1
+I
T #Index_VWert // Index erhöhen auf n+1
L #Index_VBasis // Alle Vergleichswerte geprüft? Nein
L 63 // Rücksprung
<=I
SPB MX10
//**********************************************************************************

MX99: NOP 0
 
Danke mal für deine Hilfe, unten habe ich einen Ausschnitt von meinem Programm angehängt.
Bitte schau mal drüber.
Danke.
 
Hallo JS,
die Bitmuster werden von Hand eingetragen.
es soll nur einmal eine Überprüfung statt finden ob 2 bitmuster sich gleichen, wenn ja meldung absetzen und prüfung beenden.

Hallo Rune,

spontan verstehe ich dann den Aufwand nicht. Mir fehlt der Zusammenhang...
Wenn das per Hand eingetragen wird: Sind das Rezepte oder so?
Ich persönlich würde das dann niemals als Code im Programm hinterlegen, wenn ich das tatsächlich nur einmal im SPS-Leben benötige...
Das würde ich in Excel erledigen und dann aus Excel den Code für den DB generieren.
Da Du da vielleicht auch dann bestimmte Muster hast und keine beliebigen Bit-Kombinationen, kannst Du für den Anwender Vorlagen hinterlegen für bestimmte Anwendungen. Das ermöglicht, die Zusammenstellung der Rezepte (o Ä.) an einen programmtechnisch unversierten Anwender (Kunde?) zu übergeben.

Das wäre so meine Idee... ohne den Anwendungsfall zu kennen.

Gruß
JS
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo JS,

also der Zusammenhang ist so, die verschiedenen Bitmuster 1 bis 64 stehen für verschiedene Typen. Alle Typen können unterschiedlich sein von der Bitkombination her.
Es wir dann mittels Funktion ein Bitmuster eingelesen. Die von uns eingetragen Bitmuster werden dann durchsucht und der Typ dazu ausgegeben.
Nun möchten wir gerne alle Bittmuster die von uns eingegeben wurden ein mal überprüfen ob eins von den 64 stück gleich einem anderen ist.
Dies wird über ein Bit angestoßen.
Excel bei uns nicht erlaubt und dann wandeln.
Aber anscheinend möchte mir ja keiner helfen. Oben sind Programmauszüge.
Bitmuster sollen alle gegeneinander geprüft werden. 1 mit 2, 1 mit 3,.... dann 2mit3, 2 mit 4, usw . bis alle 64 durch sind.
Dies soll nur eine Prüfung sein wenn jemand 2 gleiche Bitmuster einträgt im DB.
Ich hoffe ich habe nun genug erklärt.
Für weitere Hilfe wäre ich sehr dankbar!

Gruß euer Rune
 
Du hast das Programm geschrieben, dann wirst du es doch auch selber testen können.

Was ich nur anders machen würde ist die Prüfung ob ungleich.
Wenn du zwei Bücher vor dir liegen hast von denen du wissen willst welches die Bibel ist. Du weißt dass die Bibel mit "Am Anfang..." beginnt. Der erste Buchstabe des Buches das du prüfst ist B. Da würdest du auch nicht alle 1000 folgenden Seiten durchlesen um es zu prüfen (außer das Buch ist spannend).
 
Hallo Rune17,

ich glaube, es geht nicht ums "nicht helfen wollen"... es hat einige Ansätze in den Antworten gegeben. Nur aus allen Antworten ist ersichtlich, daß das niemand in der SPS machen würde und Dir davon abrät.

Wenn Du es aber unbedingt machen willst, würde ich mir, da es nur einmal passieren soll, keine großen Gedanken machen und so implementieren, wie es für Dich am schnellsten geht.
Ich würde in dem Falle die Prüfung von einem unkritischen Anlagezustand abhängig machen und die Zykluszeitüberwachung außer Kraft setzen (z. B. vielleicht mit DIS_IRT), so kann der Vergleich auch gut und gerne mal ein paar Sekunden dauern.

Gruß
JS
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Rune17,

ich glaube, es geht nicht ums "nicht helfen wollen"... es hat einige Ansätze in den Antworten gegeben. Nur aus allen Antworten ist ersichtlich, daß das niemand in der SPS machen würde und Dir davon abrät.

Also ich würde das mit der SPS machen, warum nicht?
Wenn es für einen Zyklus zu viel wird, teilt man es eben auf.
Aber die Aufgabe ist komplex, den meisten fehlt wohl eher die Zeit, sich da komplett reinzudenken und mal eben Code zu schreiben. Da gibt es dann eher nur Anregungen.

@Rune17

Wenn ihr die Nummern mit Hand eingebt, dann würde ich gar keine Prüfung "Jeder gegen Jeden" machen, sondern automatisch immer den gerade eingegebenen Code gegen alle anderen im DB prüfen.
Das wäre viel weniger und stellt ebenfalls sicher, dass niemals ein Duplikat im Datenbaustein landet.
 
Zuletzt bearbeitet:
Hallo,
ich würde mich mal auf deinen geposteten Code beziehen wollen.
Wenn du mit Pointern arbeitest dann solltest du dir IMMER vor Augen halten, dass das Doppelworte (gerade im Hinblick auf das Multiplikations-Ergebnis und den Integer-Grenzen) sind. Deshalb in deinem Code 2 Stellen, die ich gesehen habe, die du korrigieren solltest :
Code:
MX10: L     #Index_VBasis               // Anfangswert laden in AR1
      L     1274                                   // Startadresse ersten der 10 Byte
    [B][COLOR=#ff0000]  *D    [/COLOR][/B]
      SLD   3
      LAR1  
 
// --- die Passagen dazwischen habe ich mal herausgelassen ...

 MX20: L     #Index_VWert                // 2.Wert laden in AR1
      L     1284                        // Startadresse der zweiten 10 Byte
    [COLOR=#ff0000][B]  *D    [/B][/COLOR]
      SLD   3
      LAR1

Gruß
Larry
 
Zuletzt bearbeitet:
Eventuell könnte man zu jedem Datensatz eine Art Prüfsumme erstellen. Dann könnte man das ganze abkürzen, indem man nur solche Datensätze genauer prüft, die die gleiche Prüfsumme haben.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Aber anscheinend möchte mir ja keiner helfen.
[...]
Ich hoffe ich habe nun genug erklärt.
Für weitere Hilfe wäre ich sehr dankbar!
Wie wäre es, wenn DU uns mal ein bisschen hilfst und die Frage beantwortest, auf welcher CPU Dein Programm laufen soll und wie lange die Prüfung dauern darf/wieviel Zeit sich die CPU nehmen darf? Vielleicht ist das ja so eine Rennmaschine, daß die auch den allerdümmsten Algorithmus in 10ms erledigt? (und solche sinnfreien Vorschläge ala Zykluszeit-Überschreitung unnötig macht)


Dies soll nur eine Prüfung sein wenn jemand 2 gleiche Bitmuster einträgt im DB.
Tja dann prüfe doch auch nur dann, WENN jemand gleiche Bitmuster einträgt. ;)
Problem: Woher weiß man vor der Prüfung, ob da jetzt ein gleiches Bitmuster eingetragen wurde ;)

Vielleicht überdenkst Du nochmal Deine Aufgabenstellung und Deinen Lösungsansatz?


die Bitmuster werden von Hand eingetragen.
es soll nur einmal eine Überprüfung statt finden ob 2 bitmuster sich gleichen, wenn ja meldung absetzen und prüfung beenden.
Wenn die Prüfung bei der Eingabe jedes Wertes stattfindet, dann muß der neue Wert nur mit jedem bisher vorhandenen Wert verglichen werden. Ein Vergleichen aller Werte untereinander ist unnötig.

Ein weiterer Ansatz ist, die Werte zu sortieren, was aber auch wieder nur Sinn macht, wenn bereits beim Eintragen sortiert eingetragen wird. Dann braucht man auch nur höchstens 64 (oder gar nur ca. 8) Vergleiche statt über 2000. Jeder Versuch, nachträglich zu sortieren, hat den gleichen Aufwand wie jeden-gegen-jeden-vergleichen.

Wie geschickt die Vergleicherei vorzeitig abgebrochen wird spielt eigentlich keine Rolle. Du mußt auf jeden Fall damit rechnen, daß im ungünstigen "guten" Fall die Schleifen maximal durchlaufen werden und die maximale Suchzeit benötigt wird, bis feststeht, daß kein gleicher Wert vorhanden ist.

Harald
 
In der StandardLibrary/TI-S7ConvertingBlocks gibt es Tabellenfunktionen.
Da kann man auch nach Werten suchen.

Ansonsten würde ich die Liste sortieren.
Entweder gleich beim Sortieren auf gleiche Werte überprüfen.
Oder nach dem Sortieren.
Da muss nur noch jeder Wert mit dem Vorgänger/Nachfolger verglichen werden.


… nicht in SCL (bei uns nicht zugelassen)
???


Excel bei uns nicht erlaubt
Excel nicht erlaubt, oder generell kein Office erlaubt, auch kein anderes Tabellenprogramm (OpenOffice) ?
Mit was arbeitet Ihr denn? :confused:
 
Hallo Hub,
danke mal für deine Antwort. Du sagt was von Standard Tabellenfunktionen in S7. Was für ein FC ist das??

Excel ist schon erlaubt bei uns. Die Bitmuster sollen nur geprüft werden wenn ich es anstoße über ein Template geht das.
Die erste Adresse ist ab 1274 die nächste ab 1284 usw. Bitmuster sind ja sortiert und liegen immer 10 Byte auseinander, bzw. lang.
Beispiel hier vom DB:

Hier der DB dazu erste Adresse zum Prüfen ist ab DBX 1274.0 bis DBX1277.7
2. Adresse geht los ab DBX 1284.0 bis 1287.7 ( Bereich immer gleich 64 mal).

Typ[1].Typ_Variante[1] CHAR ' ' 'S' !* z.B. "X156, S176, N242, T246"
Typ[1].Typ_Variante[2] CHAR ' ' '1'
Typ[1].Typ_Variante[3] CHAR ' ' '7'
Typ[1].Typ_Variante[4] CHAR ' ' '6'
Typ[1].Typnummer INT 0 18 *! Typnummer 1 bis 255
Startadresse1: DBX 1274.0
Typ[1].Vorwahl_Bit_01 BOOL FALSE TRUE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_02 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_03 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_04 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_05 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_06 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_07 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_08 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_09 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_10 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_11 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_12 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_13 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_14 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_15 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_16 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_17 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_18 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_19 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_20 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_21 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_22 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_23 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_24 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_25 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_26 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_27 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_28 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_29 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_30 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_31 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[1].Vorwahl_Bit_32 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Endadresse1: DBX1277.7
Typ[2].Typ_Variante[1] CHAR ' ' 'T' !* z.B. "X156, S176, N242, T246"
Typ[2].Typ_Variante[2] CHAR ' ' '2'
Typ[2].Typ_Variante[3] CHAR ' ' '4'
Typ[2].Typ_Variante[4] CHAR ' ' '6'
Typ[2].Typnummer INT 0 17 *! Typnummer 1 bis 255
Startadresse2: DBX 1284.0
Typ[2].Vorwahl_Bit_01 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_02 BOOL FALSE TRUE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_03 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_04 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_05 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_06 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_07 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_08 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_09 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_10 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_11 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_12 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_13 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_14 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_15 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_16 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_17 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_18 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_19 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_20 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_21 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_22 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_23 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_24 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_25 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_26 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_27 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_28 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_29 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_30 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_31 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Typ[2].Vorwahl_Bit_32 BOOL FALSE FALSE !* Bit Vorwahl 0 oder 1
Endadresse2: DBX1287.7

Usw…. 64 mal gleich aufgebaut!!!!


Wie müsste das Programm jetzt aussehen bei einer Prüfung der 64 Bitmuster gegeneinander??
Wenn eine Gleichheit gefunden wird, soll eine Meldung abgesetzt werden und das Programm den Vergleich verlassen und weiter arbeiten.
Mir geht es hauptsächlich um das richtige laden der Inhalte im DB , mit SLD3 usw, AR1,usw.
da hab ich weniger Erfahrung.
Danke und Gruß Rune
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Es ist die Funktion FC86 (TBL_FIND).

Dein Begriff „Bitmuster“ hat mich erst etwas verwirrt.
Ich dachte, dein Bitmuster sind die Bits Bit_01 - Bit_32 (4Bytes/1Doppelwort).
Jetzt hab ich dein 10Byte-"Bitmuster" verstanden.
4 Byte Char, 2 Byte INT und 4 Byte Bits

Da kannst du die FC86 vergessen.

Sicherlich kann man für dein Problem eine AWL-Routine erstellen. Frage ist, ob sich einer dafür die Zeit nimmt.

Optional könnt ich mir folgende Alternativen vorstellen:

1. Der Anstoss zur Prüfung kommt von einem Template. Von einer Visualisierung?
Wenn ja, würde ich die Prüfung dort erledigen. z. B. mit VB.

2. Wenn es unbedingt in der SPS erfolgen muss, würde ich einen Baustein erstellen, bzw. erstellen lassen, der in KOP/FUB/AWL aufgerufen werden kann. Der Baustein kann dabei in SCL geschrieben sein, weil dies bei dieser Aufgabe die bessere Sprache ist. Ist im Prinzip vergleichbar mit den geschützten Standard-Bausteinen.
 
Hi Hub, gut wenn du es soweit verstanden hast, aber zu prüfen sind jeweils nur die 4 Byte Bits n nix anderes!
Die anderen Sachen interesieren nicht. Also ab 1274.0 bis 1277.7 ist der erste block dann 1284.0 bis 1287.7 usw..... 64 mal.
Hast du eine Idee.
SCL darf ich nicht schreiben, ist bei uns nicht erlaubt: Nur Step7 AWL,KOP FUP.
Gruß Rune
 
Das hört sich ja schon anders an, als im ersten Post. Es müssen also nicht 10 Byte, sondern 4 Byte ( = 1 Doppelwort) geprüft werden.
Da kannst Du doch einfach die Doppelwörter vergleichen (==D in AWL) und brauchst nicht jedes einzelne Bit prüfen.
L DBD1274
L DBD1284
==D
 
Zurück
Oben