Array in DB suchen

[Paule]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ich fürchte ich habe immer noch nicht verstanden, was das Ziel ist.
Vielleicht kannst Du den Anwendungsfall dazu erläutern.

Geht mir auch so, ein Array entsteht ja nicht einfach so, sonder es wird von irgendeinem eingegeben.
Somit wäre es eine automatische Suche von einer manuellen Eingabe, macht so etwas Sinn?
Wenn du das Programm durchsuchen willst, mach aus allen Bausteinen eine Quelle und dann einfach nach dem Text "Array" suchen (STRG+F)

 

[Limette]

..ach menno. ich probiers nochmal ...

es sollte einfach eine funktion von einem größeren programm werden. so ein art datenbank suche. ein array "xyz" steht an und es soll überprüft werden ob es das array "xyz" schon in dem db gibt oder nicht. thats it.

 

[vierlagig]

Zuviel Werbung?
-> Hier kostenlos registrieren

das heißt, die arrays kommen a) alle von aussen und werden b) mit einer eindeutigen kennung versehen?
dann bau dir ein array-verzeichnis, in dem du die einzelnen eindeutigen kennungen der arrays einträgst bzw. löschst.

dieses verzeichnis kannst du dann mit einer schleife, wie oben erwähnt, ganz einfach nach der eindeutigen kennung des vermeintlich neuen arrays durchsuchen.

 

[Larry Laffer]

... ich würde es auch so in etwa machen, wie von 4L schon beschrieben ... wobei dieser Vorschlag natürlich noch immer sehr wage bleiben muss, da die Problem-/Aufgabenstellung ja immer noch nicht vernünftig (verständlich) beschrieben ist.

Allerdings - falls die Aufgabenstellung sein sollte : durchsuche ein Array [1..100] of Array [1..6] of Byte nach einer Sequenz, die dem Baustein selbst als Array[1..6] of Byte vorgegeben worden ist, dann kann man das dann in SCL sehr schön lösen in dem man den Datenbereich, der zu durchsuchen ist über SCL selbst verwaltet (idealerweise sogar schon in der Instanz des Such-FB's hat).

Gruß
Larry

 

[Limette]

... ich würde es auch so in etwa machen, wie von 4L schon beschrieben ... wobei dieser Vorschlag natürlich noch immer sehr wage bleiben muss, da die Problem-/Aufgabenstellung ja immer noch nicht vernünftig (verständlich) beschrieben ist.

Allerdings - falls die Aufgabenstellung sein sollte : durchsuche ein Array [1..100] of Array [1..6] of Byte nach einer Sequenz, die dem Baustein selbst als Array[1..6] of Byte vorgegeben worden ist, dann kann man das dann in SCL sehr schön lösen in dem man den Datenbereich, der zu durchsuchen ist über SCL selbst verwaltet (idealerweise sogar schon in der Instanz des Such-FB's hat).

Gruß
Larry

FUNCTION FC1 : VOID
VAR_INPUT
    ToCheckARRAY: ARRAY[0..31] OF BYTE;
    
END_VAR
VAR_OUTPUT
    Found : BOOL;
    END_VAR
VAR_TEMP
    i : INT;
END_VAR
BEGIN
    
    
     FOR  i:= 1 TO 100 DO 
      IF DB1.Struktur[i].Array = ToCheckArray THEN
       Found := True;
       EXIT;
      ELSE
       Found := false;      
      END_IF;
     END_FOR;
    
    
END_FUNCTION

Ich denke wir reden jetzt vom gleichen. meine "lösung" scheitert an "ToCheckArray", ein unzulässiger Operantentyp.
Kann es so grundsätzlich gehen ? der db1 hat ja nun die entsprechende Struktur.

 

[Ralle]

Zuviel Werbung?
-> Hier kostenlos registrieren

Ich nutze u.a. DB zur Artikelverwaltung. Jeder Artikel hat z.Bsp. 300 Byte für Daten, am Anfang steht ein String[30] mit dem Artikelnamen. In SCL habe ich eine Funktion, die mehrere DB nach einem bestimmten Artikelnamen durchsuchen kann, wichtig ist nur, dass die DB regelmäßig aufgebaut sind, also die Position der Artikelnamen berechenbar ist. Der Rest ist rel. einfacher Stringvergleich.

FUNCTION FC249 : INT


Title = 'Artikel'
//
// Zuordnung der Artikelnummer an Hand eines Namens aus DB suchen
// die Daten der erste Fundstelle werden ausgegeben 
//
Version : '1.0'
author  : ralle
name    : Artikel
family  : SYSTEM


VAR_INPUT
  // Eingangsparameter
  Artikelname: STRING[30];          //gesuchter Artikelname
  Start_DB_Nummer: INT;             //Beginn der Suche bei DB
  Anzahl_DB: INT;                   //Anzahl der zu durchsuchenden DB
END_VAR


VAR_OUTPUT // Ausgangsparameter
  Artikelnummer: INT;               //Artiklenummer gesamt
  DB_Nummer:   INT;                 //DB-Nummer, in dem der Artikel zu finden ist 
  Artikelnummer_im_DB: INT;         //Artikelnummer im DB
  gefunden: BOOL;                   //Artikel wurde gefunden
END_VAR


VAR_IN_OUT // Durchgangsparameter
  Start: Bool;
END_VAR


VAR_TEMP
    // temporäre Variablen
  I, J, K: INT;
  EQ: BOOL;
  DoExit: BOOL;
  Temp_String1: STRING[30];
  atTemp_String1 AT Temp_String1: ARRAY[0..31] OF BYTE;
  Temp_String2: STRING[30];
  atTemp_String2 AT Temp_String2: ARRAY[0..31] OF BYTE;
  Quell_DB, Quell_DW: INT;  
END_VAR


// Anweisungsteil


IF Start THEN
    //Anfangswerte setzen
    FC249 := 0;
    EQ := False;
    Artikelnummer := 0;
    DB_Nummer := 0;
    Artikelnummer_im_DB := 0;
    gefunden := False;
    Temp_String1 := Artikelname;
    Temp_String2 := Artikelname;
    DoExit := False;


    //Über alle Artikel-DB
    FOR J := 0 TO Anzahl_DB - 1 DO
        
        //je DB 50 Artikel
        FOR I := 0 TO 49 DO
            Quell_DB := Start_DB_Nummer + J;
            Quell_DW := (300 * I) + 366;
        
            //Umkopieren des Artikelnamens aus dem Artikel-DB in den Temp_String2; byteweise mit Kopf
            FOR K := 0 TO 31 DO
                atTemp_String2[K] := WORD_TO_BLOCK_DB(INT_TO_WORD(Quell_DB)).DB[Quell_DW + K];
//                DB10.Temp_String2[K] := atTemp_String2[K];  //nur zum Beobachten im DB10, sonst abschalten!!!!!
            END_FOR;    


            //Länge des gefundenen Strings mit Länge des Suchstrings gleichsetzen,
            //dadurch werden auch Teilstrings gefunden, das erste Vorkommen wird dann ausgegeben
            atTemp_String2[1] := atTemp_String1[1];
                
            //Stringvergleich    
            EQ := EQ_STRNG(S1 := Temp_String1
                          ,S2 := Temp_String2 
                          );
                          
            //wenn Stringvergleich ok, dann Werte schreiben und Ende der gesamten Funktion über Exit    
            IF EQ THEN
                Artikelnummer_im_DB := I + 1;
                DB_Nummer := Quell_DB;
                Artikelnummer := (J * 50) + Artikelnummer_im_DB;
                gefunden := True;
                FC249 := Artikelnummer;
                Start := False;
                DoExit := True;
                EXIT;
            END_IF; 
        END_FOR;
        IF DoExit THEN
            EXIT;
        END_IF; 
    END_FOR; 
    Start := False;   
    DoExit := False;
 END_IF;
 
END_FUNCTION

Die Funktion ist natürlich extrem Zykluszeitfressend, wenn man ausgerechnet den letzten Artikel findet, aber da ich diese Suche nur einmalig, bei nicht laufender Automatik (Produktwechsel) durchführe, ist das in diesem Fall zweitrangig. Man kann das natürlich optimieren, indem man die For-Schleife aus mehrere Zyklen verteilt.
EQ_STRNG ist aus der Siemens-Standard-Library. Den Code hab ich gestern erst geschrieben, er ist also erst einmal nur schnell getestet und verläßt sich darauf, dass die DB auch vorhanden und lang genug angelegt sind!

 

[Larry Laffer]

Ich denke wir reden jetzt vom gleichen. meine "lösung" scheitert an "ToCheckArray", ein unzulässiger Operantentyp.
Kann es so grundsätzlich gehen ? der db1 hat ja nun die entsprechende Struktur.

Schön, wenn wir die Sache nun auf dem Punkt haben ...

Hast du im DB1 das "Array" in "DB1.Struktur" auch als ARRAY[0..31] of Byte angelegt ?
Wenn ja, dann hol dir diese IN-Variable, da du ja einen FC erstellst, erstmal in eine interne TEMP-Variable gleichen Typs und Größe und vergeiche dann mit der.

Falls du aber "im wirklichen Leben" eigentlich an dieser Stelle mit einer Zeichenkette arbeitest, so würde ich dir raten, es als String umzusetzen, da du dann insgesamt bessere Möglichkeiten hast (vorgefertigte FC's) - siehe Beispiel von Ralle.

Gruß
Larry

 

[Limette]

Schön, wenn wir die Sache nun auf dem Punkt haben ...

Hast du im DB1 das "Array" in "DB1.Struktur" auch als ARRAY[0..31] of Byte angelegt ?
Wenn ja, dann hol dir diese IN-Variable, da du ja einen FC erstellst, erstmal in eine interne TEMP-Variable gleichen Typs und Größe und vergeiche dann mit der.

Falls du aber "im wirklichen Leben" eigentlich an dieser Stelle mit einer Zeichenkette arbeitest, so würde ich dir raten, es als String umzusetzen, da du dann insgesamt bessere Möglichkeiten hast (vorgefertigte FC's) - siehe Beispiel von Ralle.

Gruß
Larry

genau das array im array of struck ist ein 32byte array. Momentan arbeite ich gerade an beiden lösungen, mal sehen welche zuerst klappt.

FUNCTION FC1 : VOID

VAR_INPUT
    ToCheckArray: ARRAY[0..31] OF BYTE;
    ToSearchDB: BLOCK_DB;
END_VAR

VAR_OUTPUT
    Gefunden : BOOL;
    DBNumber : INT;
END_VAR

VAR_TEMP
    i : INT;
    temparray: ARRAY[0..31] OF BYTE;
END_VAR

BEGIN
temparray := ToCheckArray;
    
    
     FOR  i:= 1 TO 10 DO 
      IF   [COLOR=#ff0000]DB1.Struckt[i].Array=temparray [/COLOR]
      THEN    
      Gefunden := True;
      EXIT;
    ELSE 
        Gefunden := false;      
      END_IF;
     END_FOR;
    
    
END_FUNCTION

habe das array zuerst auf ein temparray gelegt. leider mag er den rot makierten ausdruck immer noch nicht. (Operantenfehler)

 

[Paule]

Zuviel Werbung?
-> Hier kostenlos registrieren

Du schreibst doch gar nichts auf das "temparray"

 

[Limette]

Du schreibst doch gar nichts auf das "temparray"

ich dachte hier:

BEGIN
temparray := ToCheckArray;

 

[Paule]

Oh peinlich, habe ich voll übersehen. :sad:
Sollte Feierabend machen, war ein harter Tag.

Edit: Dann nur noch ein letzter Tipp!
Nimm doch für den String Vergleich den Baustein EQ_STRING so wie Ralle schon geschrieben hat:

          //Stringvergleich    
            EQ := EQ_STRNG(S1 := Temp_String1
                          ,S2 := Temp_String2 
                          );

 

[Limette]

Zuviel Werbung?
-> Hier kostenlos registrieren

Oh peinlich, habe ich voll übersehen. :sad:
Sollte Feierabend machen, war ein harter Tag.

Erst wenn du das problem gelöst hast, darfst du feierabend machen. *spaß*

 

[Limette]

Danke für diesen Code. Er umfasst mehr als ich brauche. Habe ihn mal nach meinen Bedurfnissen gesetutzt. Leider bringt der FC ständig "gefunden = 1" obwohl es nicht sein kann. Habe mein zu suchenden array of byte, zuvor per blkmov in einen string gewandelt, siehen Input.

FUNCTION FC2 : VOID
VAR_INPUT
  // Eingangsparameter
  ToCheckArray: STRING[32];
  Start_DB_Nummer: INT;             //Beginn der Suche bei DB
  
END_VAR


VAR_OUTPUT 
              
  DB_Nummer:   INT;       
  gefunden: BOOL;                   
END_VAR


VAR_IN_OUT 
  Start: Bool;
END_VAR


VAR_TEMP
  
  I, J, K: INT;
  EQ: BOOL;
  DoExit: BOOL;
  Temp_String1: STRING[32];
  atTemp_String1 AT Temp_String1: ARRAY[0..31] OF BYTE;
  Temp_String2: STRING[32];
  atTemp_String2 AT Temp_String2: ARRAY[0..31] OF BYTE;
  Quell_DB, Quell_DW: INT;  
END_VAR

IF Start THEN
    //Anfangswerte setzen
    EQ := False;    
    DB_Nummer := 0;    
    gefunden := False;
    Temp_String1 := ToCheckArray;    
    DoExit := False;
   
        
        FOR I := 0 TO 5 DO
            Quell_DB := Start_DB_Nummer + J;
            Quell_DW := (16 * I) + (1 * I); // 32byteArray + 2 byteBuffer = 34 Byte => 1 Array of Struckt        

            FOR K := 0 TO 31 DO
                atTemp_String2[K] :=WORD_TO_BLOCK_DB(INT_TO_WORD(Quell_DB)).DB[Quell_DW + K];
       
            END_FOR;    
                
            //Die Teilstringvergleiche benötige ich nicht.   
            EQ := EQ_STRNG(S1 := Temp_String1,S2 := Temp_String2);                          
        
            IF EQ THEN               
                
                gefunden := True;
                Start := False;
                DoExit := True;
                EXIT;
            END_IF; 
        END_FOR;
        IF DoExit THEN
            EXIT;
        END_IF; 
    
    Start := False;   
    DoExit := False;
END_IF;
 
END_FUNCTION

 

[Ralle]

Danke für diesen Code. Er umfasst mehr als ich brauche. Habe ihn mal nach meinen Bedurfnissen gesetutzt. Leider bringt der FC ständig "gefunden = 1" obwohl es nicht sein kann. Habe mein zu suchenden array of byte, zuvor per blkmov in einen string gewandelt, siehen Input.

FUNCTION FC2 : VOID
VAR_INPUT
  // Eingangsparameter
  ToCheckArray: STRING[32];
  Start_DB_Nummer: INT;             //Beginn der Suche bei DB
  
END_VAR


VAR_OUTPUT 
              
  DB_Nummer:   INT;       
  gefunden: BOOL;                   
END_VAR


VAR_IN_OUT 
  Start: Bool;
END_VAR


VAR_TEMP
  
  I, J, K: INT;
  EQ: BOOL;
  DoExit: BOOL;
  Temp_String1: STRING[32];
  atTemp_String1 AT Temp_String1: ARRAY[0..31] OF BYTE;
  Temp_String2: STRING[32];
  atTemp_String2 AT Temp_String2: ARRAY[0..31] OF BYTE;
  Quell_DB, Quell_DW: INT;  
END_VAR

IF Start THEN
    //Anfangswerte setzen
    EQ := False;    
    DB_Nummer := 0;    
    gefunden := False;
    Temp_String1 := ToCheckArray;    
    DoExit := False;
   
        
        FOR I := 0 TO 5 DO
            Quell_DB := Start_DB_Nummer + J;
            Quell_DW := (16 * I) + (1 * I); // 32byteArray + 2 byteBuffer = 34 Byte => 1 Array of Struckt        

            FOR K := 0 TO 31 DO
                atTemp_String2[K] :=WORD_TO_BLOCK_DB(INT_TO_WORD(Quell_DB)).DB[Quell_DW + K];
       
            END_FOR;    
                
            //Die Teilstringvergleiche benötige ich nicht.   
            EQ := EQ_STRNG(S1 := Temp_String1,S2 := Temp_String2);                          
        
            IF EQ THEN               
                
                gefunden := True;
                Start := False;
                DoExit := True;
                EXIT;
            END_IF; 
        END_FOR;
        IF DoExit THEN
            EXIT;
        END_IF; 
    
    Start := False;   
    DoExit := False;
END_IF;
 
END_FUNCTION

Mach mal den Code mit dem DB10 rein, dann kannst du dir in einer Variablentabelle ansehen, was genau umkopiert wird.

 

[Limette]

Zuviel Werbung?
-> Hier kostenlos registrieren

er kopiert bei "Start" Trigger den String von dem DB in den Test DB. Das passt ja dann schon mal. Leider wird ständig "gefunden" gesetzt obwohl die strings nicht stimmen können. "gefunden" ist eigentlich ständig "1".

edit: ne doch nicht. nur wenn der string nicht mehr als 3 stellen ("1","1","1") lang ist. Ab 4 wird nichts mehr kopiert und gefunden ist "0".

 

[Larry Laffer]

Wenn ich mir den Beispiel-Code so ansehe fällt mir das Folgende auf :
Auf die Temp-Strings wird eine AT-Sicht mit einem Array [0..31] of Byte gemacht. Das ist nicht korrekt - es müßte dann schon [-2 ..31] of byte sein, da die Strings ja noch einen Header haben.
Der Header wäre dann der nächste Punkt. hier sollte dann natürlich die max. Lnge und die deklarierte Länge (hier in beiden Fällen für die Eq_String-Funktion = 32) eingetragen werden.

Mein Vorschlag demnach :

FUNCTION FC2 : VOID
VAR_INPUT
  // Eingangsparameter
  ToCheckArray: STRING[32];
  Start_DB_Nummer: INT;             //Beginn der Suche bei DB
  
END_VAR


VAR_OUTPUT 
              
  DB_Nummer:   INT;       
  gefunden: BOOL;                   
END_VAR


VAR_IN_OUT 
  Start: Bool;
END_VAR


VAR_TEMP
  
  I, J, K: INT;
  EQ: BOOL;
  DoExit: BOOL;
  Temp_String1: STRING[32];
[B][COLOR=#FF0000]  atTemp_String1 AT Temp_String1 : struct
     Header : array [0..1] of byte ;
     Daten : array [0..31] OF BYTE;
   end_struct ;
[/COLOR][/B]  Temp_String2: STRING[32];
[B][COLOR=#FF0000]  atTemp_String2 AT Temp_String2 : struct
     Header : array [0..1] of byte ;
     Daten : array [0..31] OF BYTE;
   end_struct ;
[/COLOR][/B]  Quell_DB, Quell_DW: INT;  
END_VAR

IF Start THEN
    //Anfangswerte setzen
    EQ := False;    
    DB_Nummer := 0;    
    gefunden := False;
[COLOR=#FF0000][B]    atTemp_String1.Daten := ToCheckArray;    
    atTemp_String1.Header[0] := 32 ; atTemp_String1.Header[1] := 32 ;
[/B][/COLOR]
    DoExit := False;
   
        
        FOR I := 0 TO 5 DO
            Quell_DB := Start_DB_Nummer + J;
            Quell_DW := (16 * I) + (1 * I); // 32byteArray + 2 byteBuffer = 34 Byte => 1 Array of Struckt        

            FOR K := 0 TO 31 DO
               [B][COLOR=#FF0000] atTemp_String2.Daten[K] [/COLOR][/B]:=WORD_TO_BLOCK_DB(INT_TO_WORD(Quell_DB)).DB[Quell_DW + K];
            END_FOR;    
[B][COLOR=#ff0000]            atTemp_String2.Header[0] := 32 ; atTemp_String2.Header[1] := 32 ;[/COLOR][/B]
                
            //Die Teilstringvergleiche benötige ich nicht.   
            EQ := EQ_STRNG(S1 := Temp_String1,S2 := Temp_String2);                          
        
            IF EQ THEN               
                
                gefunden := True;
                Start := False;
                DoExit := True;
                EXIT;
            END_IF; 
        END_FOR;
        IF DoExit THEN
            EXIT;
        END_IF; 
    
    Start := False;   
    DoExit := False;
END_IF;
 
END_FUNCTION

Gruß
Larry

 

[Limette]

Danke für deine Hilfe LL.

bei

[B][COLOR=#ff0000]atTemp_String1.Daten := ToCheckArray; [/COLOR][/B]

Bringt er die Fehlermeldung zu "ToCheckArray" : ungültiger Datentyp.

 

[Larry Laffer]

Zuviel Werbung?
-> Hier kostenlos registrieren

... ich muss dir nun auch gestehen, dass ich (auch wenn mein Code es anders darstellt) das ToCheckArray noch als Array [0..31] of Byte in Erinnerung hatte. Ist es ein String, so gilt das, was ich geschrieben habe und wie ich es geschrieben habe, so nicht. Die Zuweisung von TempString_1 wäre dann, wie bei Ralle dargestellt, richtig gewesen. Das setzt dann natürlich immer noch voraus, dass der Übergabe-Parameter an den FC (ToCheckArray) korrekt formatiert ist (also die Header-Info's tatsächliche Länge und deklarierte Länge korrekt eingetragen sind). Im Falle der Schleife, die den DB-Inhalt dann aber in den TempString_2 bringt, sollte es aber so richtig sein und funktionieren, wie von mir dargestellt.

Ganz wichtig für die Verwendung aller Siemenes-String-Routinen : Die hier verwendeten Strings müssen immer korrekt formatiert sein (Header-Info wie oben genannt). Ansonsten funktionieren sie nicht oder nicht richtig.

Gruß
Larry

 

[Ralle]

Wenn ich mir den Beispiel-Code so ansehe fällt mir das Folgende auf :
Auf die Temp-Strings wird eine AT-Sicht mit einem Array [0..31] of Byte gemacht. Das ist nicht korrekt - es müßte dann schon [-2 ..31] of byte sein, da die Strings ja noch einen Header haben.
Der Header wäre dann der nächste Punkt. hier sollte dann natürlich die max. Lnge und die deklarierte Länge (hier in beiden Fällen für die Eq_String-Funktion = 32) eingetragen werden.

Mein Vorschlag demnach :

FUNCTION FC2 : VOID
VAR_INPUT
  // Eingangsparameter
  ToCheckArray: STRING[32];
  Start_DB_Nummer: INT;             //Beginn der Suche bei DB
  
END_VAR


VAR_OUTPUT 
              
  DB_Nummer:   INT;       
  gefunden: BOOL;                   
END_VAR


VAR_IN_OUT 
  Start: Bool;
END_VAR


VAR_TEMP
  
  I, J, K: INT;
  EQ: BOOL;
  DoExit: BOOL;
  Temp_String1: STRING[32];
[B][COLOR=#FF0000]  atTemp_String1 AT Temp_String1 : struct
     Header : array [0..1] of byte ;
     Daten : array [0..31] OF BYTE;
   end_struct ;
[/COLOR][/B]  Temp_String2: STRING[32];
[B][COLOR=#FF0000]  atTemp_String2 AT Temp_String2 : struct
     Header : array [0..1] of byte ;
     Daten : array [0..31] OF BYTE;
   end_struct ;
[/COLOR][/B]  Quell_DB, Quell_DW: INT;  
END_VAR

IF Start THEN
    //Anfangswerte setzen
    EQ := False;    
    DB_Nummer := 0;    
    gefunden := False;
[COLOR=#FF0000][B]    atTemp_String1.Daten := ToCheckArray;    
    atTemp_String1.Header[0] := 32 ; atTemp_String1.Header[1] := 32 ;
[/B][/COLOR]
    DoExit := False;
   
        
        FOR I := 0 TO 5 DO
            Quell_DB := Start_DB_Nummer + J;
            Quell_DW := (16 * I) + (1 * I); // 32byteArray + 2 byteBuffer = 34 Byte => 1 Array of Struckt        

            FOR K := 0 TO 31 DO
               [B][COLOR=#FF0000] atTemp_String2.Daten[K] [/COLOR][/B]:=WORD_TO_BLOCK_DB(INT_TO_WORD(Quell_DB)).DB[Quell_DW + K];
            END_FOR;    
[B][COLOR=#ff0000]            atTemp_String2.Header[0] := 32 ; atTemp_String2.Header[1] := 32 ;[/COLOR][/B]
                
            //Die Teilstringvergleiche benötige ich nicht.   
            EQ := EQ_STRNG(S1 := Temp_String1,S2 := Temp_String2);                          
        
            IF EQ THEN               
                
                gefunden := True;
                Start := False;
                DoExit := True;
                EXIT;
            END_IF; 
        END_FOR;
        IF DoExit THEN
            EXIT;
        END_IF; 
    
    Start := False;   
    DoExit := False;
END_IF;
 
END_FUNCTION

Gruß
Larry

Das müßte ich noch einmal testen, denn der von mir gepostete Code inkl. dem Vergleich funktioniert bei mir völlig problemlos, der "Header" landet in Byte 0 und Byte 1, wie das bei einem S7-String aussieht.
Ob du das Array 0..31 oder -2... 31 anlegst, ist m.E. nach einfach Geschmacksache, das betrifft eigentlich nur die Adressierbarkeit der einzelnen Bytes in der AT-Ansicht. (ich hatte String[30], also sollt 0.31 passen) Wenn ich also den Header anspreche, spreche ich Byte 0 und Byte 1 an.

PS: Den String in die Struct packen geht auch, ist aber nicht unbedingt nötig.

 

[Larry Laffer]

Hallo Ralle,
nein ... du hattest String[32] (und der ist dann ja tatsächlich ein 34-Byte-Array) - das war es dann ja, was mich dabei etwas befremdet hatte.
Ich hatte dann auch nicht die Header-Initialisierung des Temp-String 2 gefunden. Das würde dann aber schon zu dem von Limette beschriebenen Verhalten führen (oder beitragen).
Bi der Art, eine AT-Sicht darauf zu bilden kann man natürlich dann phantasievoll sein ...

Gruß
Larry