String aus DB in FC OUT-Variable kopieren

AndyM

Level-1
Beiträge
3
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
[FONT=&quot]Hallo alle zusammen,
ich möchte in Abhängigkeit einer Variable eine feste Zeichenfolge (z.B. "SV") aus meinem DB laden und an anderer Stelle im DB wieder ablegen.
Danach soll dieser String als OUT-Variable mit Format String an meinem FC anliegen. Es soll bei anschließender Parametrierung des FC`s nach der Eingabe des Typs dieser in Klartextauf an der rechten Seite stehen.

Das Kopieren innerhalb vom DB habe ich mit der SFC20 versucht zu realisieren. Ich mache da wohl einen Fehler bei der Bildung vom ANY-Pointer.
Wie ich die Ausgabe vom String an die OUT-Variable hinbekomme weis ich noch nicht. Ist das überhaupt möglich?
Es währe nett, wenn Ihr ein Paar Denkanstöße hättet.[/FONT]
Code:
 L     #TYP                        // Sprungverteiler Typ 1-5
      L     5
      ==D   
      SPB   t5

      L     #TYP
      L     4
      ==D   
      SPB   t4

      L     #TYP
      L     3
      ==D   
      SPB   t3

      L     #TYP
      L     2
      ==D   
      SPB   t2

      L     #TYP
      L     1
      ==D   
      SPB   t1

t5:   L     28                          //Typbeding Startadresse für DB
      T     #QuellDW
      SPA   end
t4:   L     22
      T     #QuellDW
      SPA   end
t3:   L     16
      T     #QuellDW
      SPA   end
t2:   L     10
      T     #QuellDW
      SPA   end
t1:   L     4
      T     #QuellDW

end:  L     #NR
      L     P#20.0                      //plus 20  (Ofset im DB)
      *I                                //Nr*10
      T     #Zeiger_5                   //Ergebnis speichern

      L     #Zeiger_5
      L     P#140.0                     //plus 140  (Startadresse im DB)
      +I    
      LAR2                              //In AR1 bereitstellen


      LAR1  P##Quelle                   //Anfangsadresse des ANY-Pointers in AR1 laden
      L     B#(16, 2)                   //Syntax-ID und Typ: Byte laden
      T     LW [AR1,P#0.0]
      L     6                           //Transferlänge
      T     LW [AR1,P#2.0]
      L     161                         //Quelle-DB
      T     LW [AR1,P#4.0]
      L     P#DBX 0.0
      L     #QuellDW                    //Anfangs-DW im Quell-DB
      ITD   
      SLD   3
      +D    
      T     LD [AR1,P#6.0]

      LAR1  P##Ziel                     //Anfangsadresse des ANY-Pointers in AR1

      L     B#(16, 2)                   //Syntax-ID und Typ: Byte laden
      T     LW [AR1,P#0.0]
      L     6                           //Transferlaenge
      T     LW [AR1,P#2.0]
      L     161                         //Ziel-DB
      T     LW [AR1,P#4.0]
      L     P#DBX 0.0                   //Anfangs-DW im Ziel-DB
      L     DBD [AR2,P#10.0]            //#ZielDW
      ITD   
      SLD   3
      +D    
      T     LD [AR1,P#6.0]

      CALL  SFC   20
       SRCBLK :=#Quelle
       RET_VAL:=#RET_1
       DSTBLK :=#Ziel
 
Ich kann dir bei dem Thema ansich zwar nicht helfen aber ich wollte mal fragen warum du keine Sprungleiste verwendest?

Code:
      L     #TYP                        // Sprungverteiler Typ 1-5
      L     5
      ==D   
      SPB   t5
 
      L     #TYP
      L     4
      ==D   
      SPB   t4
 
      L     #TYP
      L     3
      ==D   
      SPB   t3
 
      L     #TYP
      L     2
      ==D   
      SPB   t2
 
      L     #TYP
      L     1
      ==D   
      SPB   t1



Sprungleiste:

Code:
L     #TYP
SPL     end
SPA     t1
SPA     t2
SPA     t3
SPA     t4
SPA     t5

Ist vielleicht ne blöde Frage, aber ich bin noch nicht so lange dabei.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
@AndyM:
Strings können nur in der Länge 254 als Parameter für IN oder OUT verwendet werden. Den Hinweis dazu findest du in der Step7-Hilfe unter OUT-Variablendeklaration.

Gruß
LL
 
[FONT=&quot]Hallo alle zusammen,
ich möchte in Abhängigkeit einer Variable eine feste Zeichenfolge (z.B. "SV") aus meinem DB laden und an anderer Stelle im DB wieder ablegen.
Danach soll dieser String als OUT-Variable mit Format String an meinem FC anliegen. Es soll bei anschließender Parametrierung des FC`s nach der Eingabe des Typs dieser in Klartextauf an der rechten Seite stehen.

Das Kopieren innerhalb vom DB habe ich mit der SFC20 versucht zu realisieren. Ich mache da wohl einen Fehler bei der Bildung vom ANY-Pointer.
Wie ich die Ausgabe vom String an die OUT-Variable hinbekomme weis ich noch nicht. Ist das überhaupt möglich?
Es währe nett, wenn Ihr ein Paar Denkanstöße hättet.[/FONT]
Code:
 L     #TYP                        // Sprungverteiler Typ 1-5
      L     5
      ==D   
      SPB   t5

      L     #TYP
      L     4
      ==D   
      SPB   t4

      L     #TYP
      L     3
      ==D   
      SPB   t3

      L     #TYP
      L     2
      ==D   
      SPB   t2

      L     #TYP
      L     1
      ==D   
      SPB   t1

t5:   L     28                          //Typbeding Startadresse für DB
      T     #QuellDW
      SPA   end
t4:   L     22
      T     #QuellDW
      SPA   end
t3:   L     16
      T     #QuellDW
      SPA   end
t2:   L     10
      T     #QuellDW
      SPA   end
t1:   L     4
      T     #QuellDW

end:  L     #NR
      L     P#20.0                      //plus 20  (Ofset im DB)
      *I                                //Nr*10
      T     #Zeiger_5                   //Ergebnis speichern

      L     #Zeiger_5
      L     P#140.0                     //plus 140  (Startadresse im DB)
      +I    
      LAR2                              //In AR1 bereitstellen


      LAR1  P##Quelle                   //Anfangsadresse des ANY-Pointers in AR1 laden
      L     B#(16, 2)                   //Syntax-ID und Typ: Byte laden
      T     LW [AR1,P#0.0]
      L     6                           //Transferlänge
      T     LW [AR1,P#2.0]
      L     161                         //Quelle-DB
      T     LW [AR1,P#4.0]
      L     P#DBX 0.0
      L     #QuellDW                    //Anfangs-DW im Quell-DB
      ITD   
      SLD   3
      +D    
      T     LD [AR1,P#6.0]

      LAR1  P##Ziel                     //Anfangsadresse des ANY-Pointers in AR1

      L     B#(16, 2)                   //Syntax-ID und Typ: Byte laden
      T     LW [AR1,P#0.0]
      L     6                           //Transferlaenge
      T     LW [AR1,P#2.0]
      L     161                         //Ziel-DB
      T     LW [AR1,P#4.0]
      L     P#DBX 0.0                   //Anfangs-DW im Ziel-DB
      L     DBD [AR2,P#10.0]            //#ZielDW
      ITD   
      SLD   3
      +D    
      T     LD [AR1,P#6.0]

      CALL  SFC   20
       SRCBLK :=#Quelle
       RET_VAL:=#RET_1
       DSTBLK :=#Ziel

Hast du kein SCL, damit geht alles, was mit Stringmaipulation zu tun hat am Einfachsten.

Ansonsten, das hier:

Code:
end:  L     #NR
      L     P#20.0                      //plus 20  (Ofset im DB)
      *I                                //Nr*10
      T     #Zeiger_5                   //Ergebnis speichern

      L     #Zeiger_5
      L     P#140.0                     //plus 140  (Startadresse im DB)
      +I    
      LAR2
kommt mir recht eigenartig vor.
Rechne doch das ZielDW normal als Integer aus und wandle es dann in einen Pointer um, wie di es mit dem QullDW

Code:
L     P#DBX 0.0
L     #QuellDW                    //Anfangs-DW im Quell-DB
 ITD   
 SLD   3
 +D    
 T     LD [AR1,P#6.0]
ja richtig machst.

PS: Wenn es nur um 2 Zeichen geht, reicht sogar ein L DBX.DDY , denn 2 Byte sind Stringkopf und 2 Byte Zeichen. Warum hast du Transferlänge 6, sind deine Strings 4 Zeichen lang? Auch dann könnte man statt Blk_Move auch 2 Transferbefehle nutzen.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Da ja doch immer wieder Zeiger zusammengebastelt werden, stelle ich hier mal einen FC rein, der das für einen erledigt. Funktioniert aber "nur" für DB's, aber eine Anpassung sollte man dann selber machen können:

Paramer sind die DB-Nummer, die Anzahl der Bytes und die Startadresse der Bytes. Ausgabe ist dann ein Pointer auf den gewünschten Bereich, der dann z.B. mit BLKMOV weiterverwendet werden kann.

FUNCTION "DB_Pointer" : VOID
TITLE = DB_Zeiger
AUTHOR : ich...
VERSION : 0.3

VAR_INPUT
Nr_DatenDB : INT ;
Anz_Bytes : INT ;
Startbyte : INT ;
END_VAR
VAR_IN_OUT
Datenzeiger : ANY ;
END_VAR
VAR_TEMP
savear1 : DWORD ;
savear2 : DWORD ;
sendedaten : ANY ;
END_VAR
BEGIN
NETWORK
TITLE =
TAR1 ; // ar sichern
T #savear1;
L P##Datenzeiger;
LAR1 ;
L B#16#10; // 10H für S7
T B [AR1,P#0.0];
L B#16#2; // 2 für Datentyp BYTE
T B [AR1,P#1.0];
L #Anz_Bytes; // für Wiederholfaktor
T W [AR1,P#2.0];
L #Nr_DatenDB; // für DB-Nummer
T W [AR1,P#4.0];
L #Startbyte; // Startadresse der Bytes
SLD 3; // 3 nach links (Byteadresse 3 nach Links verschoben
OD DW#16#84000000; // mit 84H verodern für Speicherbereichkennung
T D [AR1,P#6.0];

LAR1 #savear1;
END_FUNCTION
 
Einspruch, Euer Ehren!

Das hier funzt:

Code:
FUNCTION FC253 : INT

Title = 'FIS_Kop'
//
// FIS-Datenbaustein füllen
//
Version : '1.0'
author  : rk
name    : FIS_KOP
family  : SYSTEM

VAR_INPUT
  // Eingangsparameter
  template: STRING[10];
  send_key_01: STRING[8];                
  send_value_01: STRING[25];             
  send_key_02: STRING[8];                
  send_value_02: STRING[25];   
  send_key_03: STRING[8];                
  send_value_03: STRING[25];             
  send_key_04: STRING[8];                
  send_value_04: STRING[25];   
  send_key_05: STRING[8];                
  send_value_05: STRING[25];             
  send_key_06: STRING[8];                
  send_value_06: STRING[25];   
  send_key_07: STRING[8];                
  send_value_07: STRING[25];             
  send_key_08: STRING[8];                
  send_value_08: STRING[25];   
  send_key_09: STRING[8];                
  send_value_09: STRING[25];             
  send_key_10: STRING[8];                
  send_value_10: STRING[25];   
  send_key_11: STRING[8];                
  send_value_11: STRING[25];
  rec_key_01: STRING[8];                
  rec_value_01: STRING[25];             
  rec_key_02: STRING[8];                
  rec_value_02: STRING[25];   
  rec_key_03: STRING[8];                
  rec_value_03: STRING[25];             
  rec_key_04: STRING[8];                
  rec_value_04: STRING[25];   
  rec_key_05: STRING[8];                
  rec_value_05: STRING[25];              
END_VAR

VAR_OUTPUT // Ausgangsparameter
  template_db: STRING[10];  
  send_key_01_db: STRING[8];                
  send_value_01_db: STRING[25];             
  send_key_02_db: STRING[8];                
  send_value_02_db: STRING[25];   
  send_key_03_db: STRING[8];                
  send_value_03_db: STRING[25];             
  send_key_04_db: STRING[8];                
  send_value_04_db: STRING[25];   
  send_key_05_db: STRING[8];                
  send_value_05_db: STRING[25];             
  send_key_06_db: STRING[8];                
  send_value_06_db: STRING[25];   
  send_key_07_db: STRING[8];                
  send_value_07_db: STRING[25];             
  send_key_08_db: STRING[8];                
  send_value_08_db: STRING[25];   
  send_key_09_db: STRING[8];                
  send_value_09_db: STRING[25];             
  send_key_10_db: STRING[8];                
  send_value_10_db: STRING[25];   
  send_key_11_db: STRING[8];                
  send_value_11_db: STRING[25]; 
  rec_key_01_db: STRING[8];                
  rec_value_01_db: STRING[25];             
  rec_key_02_db: STRING[8];                
  rec_value_02_db: STRING[25];   
  rec_key_03_db: STRING[8];                
  rec_value_03_db: STRING[25];             
  rec_key_04_db: STRING[8];                
  rec_value_04_db: STRING[25];   
  rec_key_05_db: STRING[8];                
  rec_value_05_db: STRING[25];                    
END_VAR

VAR_TEMP
    // temporäre Variablen
END_VAR

// Anweisungsteil
    template_db := template;
    send_key_01_db := send_key_01;  
    send_value_01_db := send_value_01;
    send_key_02_db := send_key_02;  
    send_value_02_db := send_value_02;
    send_key_03_db := send_key_03;  
    send_value_03_db := send_value_03;
    send_key_04_db := send_key_04;  
    send_value_04_db := send_value_04;
    send_key_05_db := send_key_05;  
    send_value_05_db := send_value_05;
    send_key_06_db := send_key_06;  
    send_value_06_db := send_value_06;
    send_key_07_db := send_key_07;  
    send_value_07_db := send_value_07;
    send_key_08_db := send_key_08;  
    send_value_08_db := send_value_08;
    send_key_09_db := send_key_09;  
    send_value_09_db := send_value_09;
    send_key_10_db := send_key_10;  
    send_value_10_db := send_value_10;
    send_key_11_db := send_key_11;  
    send_value_11_db := send_value_11;
   
    rec_key_01_db := rec_key_01;  
    rec_value_01_db := rec_value_01;
    rec_key_02_db := rec_key_02;  
    rec_value_02_db := rec_value_02;
    rec_key_03_db := rec_key_03;  
    rec_value_03_db := rec_value_03;
    rec_key_04_db := rec_key_04;  
    rec_value_04_db := rec_value_04;
    rec_key_05_db := rec_key_05;  
    rec_value_05_db := rec_value_05;
    
    ;
    FC253 := 100;
END_FUNCTION

Korrektur

Der SCL-Compiler macht da tatsächlich 254-er Strings draus, habs mal im FC selbst nachgeprüft.
Bei FB geht das allerdings.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
Einspruch abgelehnt ...

Korrekt, hatte ich ja schon korrigiert :ROFLMAO:!

Wobei man, auch wenn man lange Strings als IN und OUT definieren muß, dort dann z.Bsp. mit String[8] definierte Variablen als IN antragen und auch bearbeiten kann. Insofern stimmt mein Einspruch wieder!
 
Zuletzt bearbeitet:
Danke an Alle für die schnelle Unterstützung.

@Ralle
Hast du kein SCL, damit geht alles, was mit Stringmaipulation zu tun hat am Einfachsten.
Hab ich leider nicht...

PS: Wenn es nur um 2 Zeichen geht, reicht sogar ein L DBX.DDY , denn 2 Byte sind Stringkopf und 2 Byte Zeichen. Warum hast du Transferlänge 6, sind deine Strings 4 Zeichen lang? Auch dann könnte man statt Blk_Move auch 2 Transferbefehle nutzen.
Es geht nur um 2 Zeichen,hab aber in meinem DB 4 Zeichen vorgesehen.
Die Anweisung "L DBX.DDY" ist in meinem Fall dan L DB161.DBD 4, richtig? Wenn ich die Länge auf 2 festlege.

Gruß
AndyM
 
Danke an Alle für die schnelle Unterstützung.

@Ralle

Hab ich leider nicht...


Es geht nur um 2 Zeichen,hab aber in meinem DB 4 Zeichen vorgesehen.
Die Anweisung "L DBX.DDY" ist in meinem Fall dan L DB161.DBD 4, richtig? Wenn ich die Länge auf 2 festlege.

Gruß
AndyM

Ja genau, Byte 0 und 1 enthalten standardmäßig die Längenangabe, also Byte0=2 und Byte 1=2, in Byte 2 und 3 steht dann jeweils der Charcode für ein Zeichen (Hex31 z.Bsp für '1').

Das kann man prima sehen, wenn man sich den betreffenden Bereich des DB in der Variablentabelle Byteweise ansieht. Das ist im übrigen auch die einzige Möglichkeit, Strings Online zu beobachten bzw. deren Wert einzusehen!
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich hab jetzt mal meine FC umgeschrieben, funktioniert alles bis auf das Umkopieren in die OUT-Variable.
Die SFC 20 braucht man zum umkopieren, da man ja nicht direkt auf die Variable schreiben kann, Oder hab ich da einen Denkfehler?

Das Ganze sollte in etwa so fonktionieren, aber an die SFC20 kann ich die OUT-Variable nicht anhängen.

Code:
  L     #T_NR
      L     P#20.0                      //plus 20  (Ofset im DB)
      *I                                //T_Nr*20
      T     #Zeiger_4                   //Ergebnis speichern

      L     #Zeiger_4
      L     P#140.0                     //plus 140  (Startadresse im DB)
      +I    
      LAR1                              //In AR1 bereitstellen
//---------------------------------------------------------------------------------
      L     #TYP
      L     P#4.0                       //plus 4 (Ofset im DB)
      *I                                //T_Nr*4
      T     #Zeiger_5                   //Ergebnis speichern

      L     #Zeiger_5
      L     P#0.0                       //plus0  (Startadresse im DB)
      +I    
      LAR2                              //In AR2 bereitstellen
//---------------------------------------------------------------------------------
      L     DBD [AR2,P#0.0]             // Lade Festwert (String[2])
      T     DBD [AR1,P#0.0]             // Transferiere nach Betriebsart im Timerspeicher

      LAR2  P##Modus_tmp
      L     B#16#10                     // 10H für S7
      T     B [AR2,P#0.0]
      L     B#16#2                      // 2 für Datentyp BYTE
      T     B [AR2,P#1.0]
      L     2                           // für Wiederholfaktor
      T     W [AR2,P#2.0]
      L     161                         // für DB-Nummer
      T     W [AR2,P#4.0]
      L     DBB [AR1,P#0.0]             // Startadresse der Bytes
      SLD   3                           // 3 nach links (Byteadresse 3 nach Links verschoben
      OD    DW#16#84000000              // mit 84H verodern für Speicherbereichkennung
      T     D [AR2,P#6.0]



      CALL  SFC   20
       SRCBLK :=#Modus_tmp
       RET_VAL:=#RET_1
       DSTBLK :=#MODUS
gibt´s da noch `ne Möglichkeit das zu realisieren?

Gruß
AndyM
 
Code..

Hi,
also dein Code oben ist schon booaa hei.. was passiert da überhaupt?
Wo initialisierst du die Variablen modus_tmp und modus?

Vladi
 
[FONT=&quot]ich möchte in Abhängigkeit einer Variable eine feste Zeichenfolge (z.B. "SV") aus meinem DB laden und an anderer Stelle im DB wieder ablegen.[/FONT]
[FONT=&quot]Danach soll dieser String als OUT-Variable mit Format String an meinem FC anliegen. Es soll bei anschließender Parametrierung des FC`s nach der Eingabe des Typs dieser in Klartextauf an der rechten Seite stehen.[/FONT]

Hier ist mal ein kurzes Programmbeispiel, in dem ein STRING mit ANY-Zeigern und dem SFC20 BLKMOV kopiert wird.

Im ersten Programmteil wird ein STRING innerhalb des DB200 kopiert.

Im zweiten Programmteil wird ein STRING aus dem DB200 als OUT-Variable des FC100 ausgegeben.

Code:
ORGANIZATION_BLOCK OB 1
TITLE =Hauptprogramm
//18
AUTHOR : KAI
FAMILY : SPSFORUM
NAME : 'STRING'
VERSION : 1.0
 
VAR_TEMP
  OB1_EV_CLASS : BYTE ; //Bits 0-3 = 1 (Coming event), Bits 4-7 = 1 (Event class 1)
  OB1_SCAN_1 : BYTE ; //1 (Cold restart scan 1 of OB 1), 3 (Scan 2-n of OB 1)
  OB1_PRIORITY : BYTE ; //Priority of OB Execution
  OB1_OB_NUMBR : BYTE ; //1 (Organization block 1, OB1)
  OB1_RESERVED_1 : BYTE ; //Reserved for system
  OB1_RESERVED_2 : BYTE ; //Reserved for system
  OB1_PREV_CYCLE : INT ; //Cycle time of previous OB1 scan (milliseconds)
  OB1_MIN_CYCLE : INT ; //Minimum cycle time of OB1 (milliseconds)
  OB1_MAX_CYCLE : INT ; //Maximum cycle time of OB1 (milliseconds)
  OB1_DATE_TIME : DATE_AND_TIME ; //Date and time OB1 started
END_VAR
BEGIN
NETWORK
TITLE =STRING kopieren
 
      CALL FC   100 (
           QUELLE_NUMMER            := MW   100,
           ZIEL_NUMMER              := MW   102,
           ZIEL_STRING              := DB200.ZIEL_5);
      NOP   0; 
 
END_ORGANIZATION_BLOCK

Code:
FUNCTION FC 100 : VOID
TITLE =STRING kopieren
//14
AUTHOR : KAI
FAMILY : SPSFORUM
NAME : 'STRING'
VERSION : 1.0
 
VAR_INPUT
  QUELLE_NUMMER : INT ; 
  ZIEL_NUMMER : INT ; 
END_VAR
VAR_OUTPUT
  ZIEL_STRING : STRING  [254 ]; 
END_VAR
VAR_TEMP
  DB_REGISTER : WORD ; 
  AR1_REGISTER : DWORD ; 
  STARTADRESSE : INT ; 
  QUELLE_ANY : ANY ; 
  ZIEL_ANY : ANY ; 
  DB_NUMMER : WORD ; 
  BEREICHSZEIGER : DWORD ; 
  BLKMOV : INT ; 
END_VAR
BEGIN
NETWORK
TITLE =DB-Register und AR1-Register sichern
 
      L     DBNO; // DB-Register
      T     #DB_REGISTER; 
 
      TAR1  #AR1_REGISTER; // AR1-Register
 
NETWORK
TITLE =QUELLE STARTADRESSE
//STARTADRESSE = (QUELLE_NUMMER - 1) * 6
//   
      L     #QUELLE_NUMMER; // QUELLE Nummer
      T     #STARTADRESSE; // Startadresse
 
      L     #STARTADRESSE; // Startadresse > 4
      L     4; 
      >I    ; 
      SPBN  M10; 
      L     4; 
      T     #STARTADRESSE; // Startadresse
 
M10:  L     #STARTADRESSE; // Startadresse < 1
      L     1; 
      <I    ; 
      SPBN  M11; 
      L     1; 
      T     #STARTADRESSE; // Startadresse
 
M11:  L     #STARTADRESSE; // Startadresse
      L     1; 
      -I    ; 
      L     6; 
      *I    ; 
      T     #STARTADRESSE; // Startadresse
 
NETWORK
TITLE =QUELLE_ANY (ANY)
 
      L     P##QUELLE_ANY; // QUELLE ANY (ANY) 
      LAR1  ; 
 
      L     B#16#10; // Syntax-ID
      T     LB [AR1,P#0.0]; 
 
      L     2; // Datentyp
      T     LB [AR1,P#1.0]; 
 
      L     6; // Anzahl
      T     LW [AR1,P#2.0]; 
 
      L     200; // DB-Nummer
      T     LW [AR1,P#4.0]; 
 
      L     #STARTADRESSE; // Bereichszeiger
      ITD   ; 
      SLD   3; 
      T     LD [AR1,P#6.0]; 
 
      L     B#16#84; // Operandenbereich
      T     LB [AR1,P#6.0]; 
 
NETWORK
TITLE =ZIEL STARTADRESSE
//STARTADRESSE = ((ZIEL_NUMMER - 1) * 6) + 24
//   
      L     #ZIEL_NUMMER; // ZIEL Nummer
      T     #STARTADRESSE; // Startadresse
 
      L     #STARTADRESSE; // Startadresse > 4
      L     4; 
      >I    ; 
      SPBN  M20; 
      L     4; 
      T     #STARTADRESSE; // Startadresse
 
M20:  L     #STARTADRESSE; // Startadresse < 1
      L     1; 
      <I    ; 
      SPBN  M21; 
      L     1; 
      T     #STARTADRESSE; // Startadresse
 
M21:  L     #STARTADRESSE; // Startadresse
      L     1; 
      -I    ; 
      L     6; 
      *I    ; 
      L     24; 
      +I    ; 
      T     #STARTADRESSE; // Startadresse
 
NETWORK
TITLE =ZIEL_ANY (ANY)
 
      L     P##ZIEL_ANY; // ZIEL ANY (ANY) 
      LAR1  ; 
 
      L     B#16#10; // Syntax-ID
      T     LB [AR1,P#0.0]; 
 
      L     2; // Datentyp
      T     LB [AR1,P#1.0]; 
 
      L     6; // Anzahl
      T     LW [AR1,P#2.0]; 
 
      L     200; // DB-Nummer
      T     LW [AR1,P#4.0]; 
 
      L     #STARTADRESSE; // Bereichszeiger
      ITD   ; 
      SLD   3; 
      T     LD [AR1,P#6.0]; 
 
      L     B#16#84; // Operandenbereich
      T     LB [AR1,P#6.0]; 
 
NETWORK
TITLE =QUELLE (STRING) => ZIEL (STRING)
 
      CALL SFC   20 (
           SRCBLK                   := #QUELLE_ANY,
           RET_VAL                  := #BLKMOV,
           DSTBLK                   := #ZIEL_ANY);
      NOP   0; 
 
NETWORK
TITLE =ZIEL_STRING (POINTER)
 
      L     P##ZIEL_STRING; // ZIEL STRING (POINTER)
      LAR1  ; 
 
      L     W [AR1,P#0.0]; // DB-Nummer
      T     #DB_NUMMER; 
 
      L     D [AR1,P#2.0]; // Bereichszeiger
      T     #BEREICHSZEIGER; 
 
NETWORK
TITLE =ZIEL_ANY (ANY)
 
      L     P##ZIEL_ANY; // ZIEL ANY (ANY)
      LAR1  ; 
 
      L     B#16#10; // Syntax-ID
      T     LB [AR1,P#0.0]; 
 
      L     2; // Datentyp
      T     LB [AR1,P#1.0]; 
 
      L     6; // Anzahl
      T     LW [AR1,P#2.0]; 
 
      L     #DB_NUMMER; // DB-Nummer
      T     LW [AR1,P#4.0]; 
 
      L     #BEREICHSZEIGER; // Bereichszeiger
      T     LD [AR1,P#6.0]; 
 
NETWORK
TITLE =QUELLE (STRING) => ZIEL_STRING (STRING)
 
      CALL SFC   20 (
           SRCBLK                   := #QUELLE_ANY,
           RET_VAL                  := #BLKMOV,
           DSTBLK                   := #ZIEL_ANY);
      NOP   0; 
 
NETWORK
TITLE =DB-Register und AR1-Register wiederherstellen
 
      AUF   DB [#DB_REGISTER]; // DB-Register
 
      LAR1  #AR1_REGISTER; // AR1-Register
 
END_FUNCTION

Gruß Kai
 

Anhänge

  • OB1.pdf
    5,8 KB · Aufrufe: 30
  • FC100.pdf
    10,5 KB · Aufrufe: 34
  • DB200.pdf
    5,1 KB · Aufrufe: 25
  • PLCSIM.jpg
    PLCSIM.jpg
    555,1 KB · Aufrufe: 35
  • String.zip
    37,5 KB · Aufrufe: 26
Zuviel Werbung?
-> Hier kostenlos registrieren
Was mich immer wundert:

Als Beispiel, ganz normaler Blockmove:

CALL SFC 20 (
SRCBLK := P#M100.0 byte 10
RET_VAL := #BLKMOV,
DSTBLK := P#M150.0 byte 10

Logisch...Die Bytes ab MB100 werden nach MB150 kopiert.





Wenn ich jetzt aber vorher meine Bytes ab MB150 mit dem Anypointer füttere


L P##ZIEL_ANY; // ZIEL ANY (ANY)
LAR1 ;

L B#16#10; // Syntax-ID
T MB150

L 2; // Datentyp
T MB151

L 6; // Anzahl
T MW152

L 200; // DB-Nummer
T MW154

L #STARTADRESSE; // Bereichszeiger
ITD ;
SLD 3;
T MD156

L B#16#84; // Operandenbereich
T MB156


CALL SFC 20 (
SRCBLK := P#M100.0 byte 10
RET_VAL := #BLKMOV,
DSTBLK := P#M150.0 byte 10

Jetzt werden die Bytes ja nicht nach MB150-159, sondern in den DB200 kopiert.

Woher weiß das Ding das??
Wieso kopiert der das nicht wieder nach MB150? Denn, der Movebefehl wird ja gleich "gefüttert"... :confused:
 
Wohin in DB200 wurden denn die Daten kopiert?
Probiere mal, was passiert, wenn du asl DB.Nummer eine 0 eingibst in MW154.
 
Hab es einfach mal vom Kai kopiert, den Pointer. Ist ja auch richtig wenn er es in den DB200 kopiert. (Habs nehrlich gesagt nicht ausprobiert)

Wollte nur wissen woher die SPS, bei der gleichen "Versorgung" des SFC20, weiß ob sie die Daten jetzt ins die MB150-159 kopieren soll ODER in das Ziel was in den MB150-159 steht. Also worauf der Anypointer "zeigt".

Liegt es an der SyntaxID oder woran...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Code:
L P##ZIEL_ANY; // ZIEL ANY (ANY) 
LAR1 ; 

L B#16#10; // Syntax-ID
T MB150 

L 2; // Datentyp
T MB151

L 6; // Anzahl
T MW152

L 200; // DB-Nummer
T MW154

L #STARTADRESSE; // Bereichszeiger
ITD ; 
SLD 3; 
T MD156

[COLOR=red]L B#16#84; // Operandenbereich hier wird vorgegeben ob M,DB...[/COLOR]
T MB156

Hoffe du verstehst das jetzt.
Volker hat das auch sehr gut beschrieben unter FAQ. Any-Pionter.
gruß gerhard k
 
Danke!

Das mein ich leider nicht...

Weiß auch nicht wie ich es sonst erklären soll. Egal.
Funktioniert ja...


Gruß
 
Zuletzt bearbeitet:
Code:
L P##ZIEL_ANY; // ZIEL ANY (ANY) 
LAR1 ; 
 
L B#16#10; // Syntax-ID
T MB150 
 
L 2; // Datentyp
T MB151
 
L 6; // Anzahl
T MW152
 
[COLOR=red]L 200; // DB-Nummer // 0 =kein DB[/COLOR] 
L MW154
 
L #STARTADRESSE; // Bereichszeiger
ITD ; 
SLD 3; 
T MD156
 
[COLOR=red]L B#16#84; // Operandenbereich hier wird vorgegeben ob M,DB...[/COLOR]
T MB156
vielleicht ist das deine Lösung
Hab mir die ganzen vorherigen Sachen nicht durchgelesen.
 
Zurück
Oben