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

Seite 1 von 4 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 38

Thema: Bitmusterüberprüfung mittels Schleife in AWL

  1. #1
    Registriert seit
    21.04.2015
    Beiträge
    11
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    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
    Zitieren Zitieren Bitmusterüberprüfung mittels Schleife in AWL  

  2. #2
    Registriert seit
    23.07.2009
    Ort
    Österreich
    Beiträge
    2.367
    Danke
    457
    Erhielt 696 Danke für 521 Beiträge

    Standard

    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.
    Geändert von RONIN (23.04.2015 um 10:12 Uhr)
    If at first you don't succeed, you're not Van Damme!
    ... or maybe using TIA!

  3. #3
    Registriert seit
    22.06.2009
    Ort
    Sassnitz
    Beiträge
    11.293
    Danke
    932
    Erhielt 3.320 Danke für 2.682 Beiträge

    Standard

    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
    Es ist immer wieder überraschend, wie etwas plötzlich funktioniert, sobald man alles richtig macht.

    FAQ: Linkliste SIMATIC-Kommunikation über Ethernet

  4. Folgender Benutzer sagt Danke zu PN/DP für den nützlichen Beitrag:

    RONIN (22.04.2015)

  5. #4
    Registriert seit
    03.02.2015
    Ort
    Hatten
    Beiträge
    183
    Danke
    16
    Erhielt 32 Danke für 29 Beiträge

    Standard

    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

  6. #5
    Rune17 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    21.04.2015
    Beiträge
    11
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    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.

  7. #6
    Rune17 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    21.04.2015
    Beiträge
    11
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    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

  8. #7
    Rune17 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    21.04.2015
    Beiträge
    11
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Danke mal für deine Hilfe, unten habe ich einen Ausschnitt von meinem Programm angehängt.
    Bitte schau mal drüber.
    Danke.

  9. #8
    Registriert seit
    03.02.2015
    Ort
    Hatten
    Beiträge
    183
    Danke
    16
    Erhielt 32 Danke für 29 Beiträge

    Standard

    Zitat Zitat von Rune17 Beitrag anzeigen
    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

  10. #9
    Rune17 ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    21.04.2015
    Beiträge
    11
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    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

  11. #10
    Registriert seit
    29.03.2004
    Beiträge
    5.792
    Danke
    144
    Erhielt 1.706 Danke für 1.238 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    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).

Ähnliche Themen

  1. Step 7 AWL - Schleife mit Array
    Von bo1986 im Forum Simatic
    Antworten: 5
    Letzter Beitrag: 19.06.2013, 12:57
  2. Antworten: 4
    Letzter Beitrag: 17.11.2011, 10:38
  3. awl schleife und pointer
    Von Iserlohner im Forum Simatic
    Antworten: 28
    Letzter Beitrag: 18.02.2011, 09:12
  4. IF oder FOR Schleife in AWL?
    Von motamas im Forum Simatic
    Antworten: 6
    Letzter Beitrag: 21.07.2010, 14:19
  5. AWL Schleife
    Von Anonymous im Forum Simatic
    Antworten: 6
    Letzter Beitrag: 31.07.2003, 07:05

Lesezeichen

Berechtigungen

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