Step 7 SCL Stringverarbeitung Lokaldaten

B

Barthiboy

Level-1
Beiträge
9
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo Zusammen,

ich arbeite an einer Roboteransteuerung, bei der über TCP/IP Strings an die Robotersteuerung gesendet werden.
Dies habe ich in einer SCL Quelle realisiert.
Hat auch alles wunderbar funktioniert.

Ich habe hier nur leider das 64kB Codelimit geknackt.
Darauf hin wollte ich die Funktionen in mehrere FB´s aufteilen.
Habe ich dann auch gemacht
So weit so gut.
Allerdings ist jetzt die Anzahl der Lokaldaten riesig geworden. Ich habe eine 3-19er und somit 1024 Byte Lokaldaten.
Es ist aber nach wie vor der gleiche Code nur in mehrere FB´s aufgeteilt.
Der Unterschied ist der, das es anstatt dem ersten InstanzDB jetzt einen DB gibt, in dem ich die Ctrl Struktur für die einzelnen Befehle realisiert habe.
Hierfür gibt es einen UDT.
Ich habe jetzt probiert die Ctrl Struktur al Var_input zu übergeben, allerdings generiert das auch riesige Lokaldaten(ist soweit auch klar)
Witziger weise auch wenn ich auf den DB direkt also z.b DB31.Ctrl.DoMove zugreife
Und nur den Zeiger quasi als Var_In_out zu übergeben geht nicht, weil dieser Zeiger nicht an die Stringfunktionen weitergereicht werden kann.

Was mir nun richtig schleierhaft ist:
Ich habe eine SCL Quelle, in der alle Variablen deklariert werden und ein haufen Stringfunktionen aufgerufen werden -> Wenig lokaldaten
Ich habe eine SCL Quelle, in der ein UDT zur Deklaration verwendet wird und haufen Stringfunktionen aufgerufen werden -> viele lokaldaten

Ich bin nicht sicher ob die Erklärungen soweit ausreichen. Ansonsten bitte nachfragen.

Gibt es jetzt Compilereinstellung mit denen man dieses Verhalten verbessern kann?
Oder eine Möglichkeit die Lokaldaten zu reduzieren?
Vielen Dank für eure Hilfe
 
Zeig mal bissle Code dazu, vor allem die Deklaration. Mir scheint es handelt sich um eine ganze Menge Strings, wie bearbeitest du die? Mit Schleifen?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Code: 
TYPE "UDT_RC180_Ctrl"
  STRUCT    
    IsBusy : BOOL;              // Abfrage aktiv 
    Pause : BOOL;               // Verfahrbefehl pausieren
    Step : INT;                 // Schrittkette         
  // Schreiben
    DoSetEnde : STRUCT
      DoIt : BOOL;              // Und ab geht´s
      DoItHMI : BOOL;           // Und ab geht´s 
      Done : BOOL;              // Feddisch
      NoHandshake : BOOL;       // Der Befehl wird abgeschlossen ohne DoIt 1->0
      Freigabe : BOOL;          // Freigabe
      IsError : BOOL;           // Fehler vorhanden
      ErrorID : WORD;           // Fehlernummer
      Step : INT;               // Schrittkette
    END_STRUCT;
          
    DoSetAccel : STRUCT         // Beschleunigung/Verzögerung
      DoIt : BOOL;              // Und ab geht´s
      DoItHMI : BOOL;           // Und ab geht´s 
      Done : BOOL;              // Feddisch
      NoHandshake : BOOL;       // Der Befehl wird abgeschlossen ohne DoIt 1->0
      Freigabe : BOOL;          // Freigabe
      IsError : BOOL;           // Fehler vorhanden
      ErrorID : WORD;           // Fehlernummer
      Step : INT;               // Schrittkette
      Accel : WORD;             // 0-100% Beschleunigung
      DepartAccel : WORD;       // 0-100% Depart Beschleunigung
      ApproAccel : WORD;        // 0-100% Approach Verzögerung
      Decel : WORD;             // 0-100% Verzögerung
      DepartDecel : WORD;       // 0-100% Depart Verzögerung
      ApproDecel : WORD;        // 0-100% Approach Verzögerung      
    END_STRUCT;
.
.
.
.
.
  END_STRUCT
END_TYPE



der DB


DATA_BLOCK DB31
  STRUCT
    Ctrl          : "UDT_RC180_Ctrl"; 
    KommCtrl      : "UDT_RC180_Komm_Ctrl";
    Properties    : "UDT_RC180_Prop";
  END_STRUCT
BEGIN  
END_DATA_BLOCK


der Haupt FB
FUNCTION_BLOCK "00FB_EpsonRC180"
TITLE = 'JH_FB_RC180_ETH'
VERSION : '1.0'
AUTHOR  : 'JH'    
NAME    : 'Epson'
FAMILY  : 'Roboter'
CONST
  TCPSize           := 150;
END_CONST


VAR_INPUT
  RESET             : BOOL; 
  ANLAUF            : BOOL;
  Config            : "TCON_PAR";
  Ctrl              : "UDT_RC180_Ctrl";
  KommCtrl          : "UDT_RC180_Komm_Ctrl";
  Properties        : "UDT_RC180_Prop";    
  ServerLaeuft      : BOOL;         // Hardware Output von Roboter 
  ServerReady       : BOOL;         // Hardware Output von Roboter
  ServerEStopOn     : BOOL;         // Hardware Output von Roboter 
  ServerError       : BOOL;         // Hardware Output von Roboter
END_VAR


VAR_OUTPUT
  IsError           : BOOL;
  ErrorID           : DWORD;
  ServerStart       : BOOL;         // Hardware Input von Roboter
  PauseBefehl       : BOOL;         // Hardware Input von Roboter
  ResumeBefehl      : BOOL;         // Hardware Input von Roboter
  ServerReset       : BOOL;         // Reset Hardware Input von Roboter
  ServerStop        : BOOL;         // Hardware Input von Roboter
END_VAR 


VAR  
  //----| VAR STAT |---- Verbindungsvariablen -----------------------------------------------------------------------|}
  fbCon             : "TCON";       // Eingangsvariable des Bausteins fbCon
  fbRecv            : "TRCV";       // Eingangsvariable des Bausteins fbRecv
  fbSend            : "TSEND";      // Eingangsvariable des Bausteins fbSend
  fbDiscon          : "TDISCON";    // Eingangsvaribale des Bausteins fbDISCON    
   
  NonS7StrToRealStr : "00FB_NonS7StrToRealStr";
  
  ResetSteps        : BOOL; 
  TimeOut           : TON;    
  Time300           : TON;
  Toggle300ms       : BOOL;
  
  
  
  //----| VAR STAT |---- übergeordnete Ansteuerung ------------------------------------------------------------|}
  // Befehlsstruktur:
  // 1-Do : Wenn ein Befehl abgesetzt wird
  // 2-Set : Schreibend auf den Roboter zugreifen
  // 2-Get : Lesend auf den Roboter zugreifen
  // 3-XXX : SPEL Befehl


  AWordForBool      : WORD;
  AWordBoolArray AT AWordFo+rBool : ARRAY[0..15] OF BOOL;


 Server : STRUCT
    Step      : INT;
  END_STRUCT;  
END_VAR


VAR_TEMP
//----| VAR TEMP |---- Sonstiges -----------------------------------------------------------------------------------|}
  AWord             : WORD;
  ADWord            : DWORD;
  AInt              : INT;
  ADInt             : DINT;
  i                 : INT;
  ALen              : INT;
  RealToStrOK       : BOOL;
  AReal             : REAL;


END_VAR


//------------------------------------------------------------------------------------------------------------------------------------------------------//
                                                                    // --  Programmstart  -- //
//------------------------------------------------------------------------------------------------------------------------------------------------------//


BEGIN

dann kommunikationshandling usw

hier beispielhaft ein Aufruf

//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// ------------ DoGetCX ---------------------------------------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  IF (NOT Ctrl.IsBusy) AND (Ctrl.DoSetCX.DoIt OR Ctrl.DoSetCX.DoItHMI) AND (NOT IsError) AND (NOT (Ctrl.DoSetCX.Step > 0)) AND Ctrl.DoSetCX.Freigabe THEN
    Ctrl.DoSetCX.Step                := 1;
    Ctrl.IsBusy                         := True;
    Ctrl.DoSetCX.Done                := False;      
  END_IF;    
    
  CASE Ctrl.DoSetCX.Step OF
    1://Empfangsbereitschaft aktivieren 
      FOR i:=0 TO TCPSize-1 DO
        KommCtrl.RecArray[i]                 := char#0;
      END_FOR;          
      KommCtrl.EmpfangenGesBef               := 0;
      KommCtrl.EmpfangenLaBef                := 0;
      KommCtrl.Receive_DoREQBef              := True;
      Ctrl.DoSetCX.Step          := Ctrl.DoSetCX.Step + 1; 
        
    2://Kommandostring senden:
      IF NOT KommCtrl.Send_DoREQ AND NOT KommCtrl.Send_IsBusy AND NOT KommCtrl.PropKomplett AND NOT KommCtrl.BefehlKomplett AND NOT KommCtrl.Receive_IsBusy THEN  // Evtl. warten bis Senden von Properties abgeschlossen        
        KommCtrl.Sendelaenge                   := 6;       
        KommCtrl.SendArray[0]                  := 'W';
        KommCtrl.SendArray[1]                  := 'r';       
        KommCtrl.SendArray[2]                  := ',';       
        KommCtrl.SendArray[3]                  := 'C';       
        KommCtrl.SendArray[4]                  := 'X';                      
        KommCtrl.SendArray[5]                 := ',';
        
        KommCtrl.AStr                          := INT_TO_STRING(WORD_TO_INT(Ctrl.DoSetCX.Index));
        FOR i:=2 TO (LEN(KommCtrl.AStr)) DO 
          KommCtrl.SendArray[KommCtrl.Sendelaenge-2+i]  := STRING_TO_CHAR(MID(in:=KommCtrl.AStr, l:=1, p:=i)); // 1 daneben -> + abschneiden
          KommCtrl.Sendelaenge                 := KommCtrl.Sendelaenge + 1;
        END_FOR;            
        KommCtrl.Sendelaenge                     := KommCtrl.Sendelaenge + 15;
        KommCtrl.SendArray[KommCtrl.Sendelaenge]                 := ',';  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+1]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=1));  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+2]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=2)); 
        KommCtrl.SendArray[KommCtrl.Sendelaenge+3]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=3));  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+4]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=4));  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+5]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=5));  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+6]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=6));  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+7]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=7));  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+8]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=8));  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+9]               := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=9));  
        KommCtrl.SendArray[KommCtrl.Sendelaenge+10]              := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=10));      
        KommCtrl.SendArray[KommCtrl.Sendelaenge+11]              := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=11)); 
        KommCtrl.SendArray[KommCtrl.Sendelaenge+12]              := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=12)); 
        KommCtrl.SendArray[KommCtrl.Sendelaenge+13]              := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=13)); 
        KommCtrl.SendArray[KommCtrl.Sendelaenge+14]              := STRING_TO_CHAR(MID(in:=KommCtrl.RealString, l:=1, p:=14)); 
        KommCtrl.Sendelaenge                   := KommCtrl.Sendelaenge + 2;
        KommCtrl.SendArray[KommCtrl.Sendelaenge-2]                 := '$0D';              
        KommCtrl.SendArray[KommCtrl.Sendelaenge-1]                 := '$0A';       
                 
        KommCtrl.Send_DoREQ                    := True;
        Ctrl.DoSetCX.Step          := Ctrl.DoSetCX.Step + 1; 
      END_IF;
      
    3://Kommando fertig       
      IF KommCtrl.Send_IsDone AND NOT KommCtrl.Send_IsBusy THEN
        KommCtrl.Send_DoREQ                  := False;
        Ctrl.DoSetCX.Step        := Ctrl.DoSetCX.Step + 1;  
      END_IF;      
    
    4://Daten empfangen. Mindestens die Länge ist schon angekommen                
      IF KommCtrl.BefehlKomplett THEN 
        KommCtrl.BefehlKomplett              := False; 
        // Antwort auswerten 
        AInt := FIND(IN1 := KommCtrl.RecStrBefehl, IN2 := 'ERROR:');
        IF AInt > 0 THEN
          Ctrl.DoSetCX.IsError             := True;
          KommCtrl.AStr := MID(IN := KommCtrl.RecStrBefehl, L:= (LEN(KommCtrl.RecStrBefehl)-(AInt + 8)), P := AInt+7);
          Ctrl.DoSetCX.ErrorID := INT_TO_WORD(STRING_TO_INT(KommCtrl.AStr));
          AInt := WORD_TO_INT(ENO);
        END_IF;        
        Ctrl.DoSetCX.Step        := 100;           
      END_IF;
      
    100://Schrittkette beenden     
      Ctrl.DoSetCX.Done         := True;
      KommCtrl.BefehlKomplett                  := False;     
      IF ((NOT Ctrl.DoSetCX.DoIt) AND (NOT Ctrl.DoSetCX.DoItHMI) OR (Ctrl.DoSetCX.NoHandshake AND NOT Ctrl.DoSetCX.IsError)) THEN
        Ctrl.DoSetCX.Step       := 0; 
        Ctrl.IsBusy                   := False;
        Ctrl.DoSetCX.Done       := False;
        Ctrl.DoSetCX.IsError    := False;
        Ctrl.DoSetCX.ErrorID    := 0;   
      END_IF;   
  END_CASE;
 
Hier ist noch das Abfragen des Status

Code: 
  CASE Properties.Step OF    0://Empfangsbereitschaft aktivieren 
      IF Toggle300ms THEN //AND false THEN // AND NOT Ctrl.IsBusy THEN 
        FOR i:=0 TO TCPSize-1 DO
          KommCtrl.RecArray[i]                 := char#0;
        END_FOR;          
        KommCtrl.EmpfangenGesProp              := 0;
        KommCtrl.EmpfangenLaProp               := 0;
        KommCtrl.HeaderLaProp                  := 0;        
        Properties.Step               := Properties.Step + 1; 
      END_IF;
                
    1://Kommandostring senden:
      IF NOT KommCtrl.Send_DoREQ AND NOT KommCtrl.Send_IsBusy AND NOT KommCtrl.PropKomplett AND NOT KommCtrl.BefehlKomplett THEN  // Evtl. warten bis Senden von Befehl abgeschlossen
        KommCtrl.SendArray[0] := 'R';
        KommCtrl.SendArray[1] := 'd';       
        KommCtrl.SendArray[2] := ',';       
        KommCtrl.SendArray[3] := 'P';       
        KommCtrl.SendArray[4] := 'r';       
        KommCtrl.SendArray[5] := 'o';       
        KommCtrl.SendArray[6] := 'p'; 
        KommCtrl.SendArray[7] := 'e';                   
        KommCtrl.SendArray[8] := 'r';  
        KommCtrl.SendArray[9] := 't';  
        KommCtrl.SendArray[10] := 'i';  
        KommCtrl.SendArray[11] := 'e';  
        KommCtrl.SendArray[12] := 's';                    
        KommCtrl.SendArray[13] := ',';  
        KommCtrl.SendArray[14] := '0'; 
        KommCtrl.SendArray[15] := ',';  
        KommCtrl.SendArray[16] := '0';       
        KommCtrl.SendArray[17] := '$0D';              
        KommCtrl.SendArray[18] := '$0A';       
        KommCtrl.Sendelaenge                   := 19;
      
        KommCtrl.Receive_DoREQProp             := True;
        KommCtrl.Send_DoREQ                    := True;
        Properties.Step           := Properties.Step + 1;
      END_IF;
                 
    2://Kommando fertig       
      IF KommCtrl.Send_IsDone AND NOT KommCtrl.Send_IsBusy THEN
        KommCtrl.Send_DoREQ                  := False;
        Properties.Step   := Properties.Step + 1;  
      END_IF;      


    3://Daten empfangen. Mindestens die Länge ist schon angekommen                
      IF KommCtrl.PropKomplett THEN 
        KommCtrl.PropKomplett                := False; 
        
        // HighByte und LowByte vertauschen !!!
        KommCtrl.AStr := MID(in:=KommCtrl.RecStrProp, l:=5, p:=20);                 
        AWordForBool := INT_TO_WORD(STRING_TO_INT(KommCtrl.AStr));  // Read Inputs 17-24
        FOR i:=17 TO 24 DO // Input 17-24
          Properties.Input[i]                 := AWordBoolArray[i-9];
        END_FOR;              
        
        KommCtrl.AStr := MID(in:=KommCtrl.RecStrProp, l:=5, p:=25);        
        AWordForBool := INT_TO_WORD(STRING_TO_INT(KommCtrl.AStr));  // Read Inputs 1-16
        FOR i:=1 TO 8 DO // Input 1-16
          Properties.Input[i]                 := AWordBoolArray[i+7];
        END_FOR;    
        FOR i:=9 TO 16 DO // Input 1-16
          Properties.Input[i]                 := AWordBoolArray[i-9];
        END_FOR;   
                  
        KommCtrl.AStr := MID(in:=KommCtrl.RecStrProp, l:=5, p:=30);
        AWordForBool := INT_TO_WORD(STRING_TO_INT(KommCtrl.AStr));  // Read Outputs 1-16
        FOR i:=1 TO 8 DO // Output 1-16
          Properties.Output[i]                 := AWordBoolArray[i+7];
        END_FOR; 
        FOR i:=9 TO 16 DO // Output 1-16
          Properties.Output[i]                 := AWordBoolArray[i-9];
        END_FOR;         
        
        KommCtrl.AStr := MID(in:=KommCtrl.RecStrProp, l:=5, p:=35);
        Properties.ErrorCode := INT_TO_WORD(STRING_TO_INT(KommCtrl.AStr));
                   
        KommCtrl.AStr := MID(in:=KommCtrl.RecStrProp, l:=5, p:=40);
        AWordForBool := INT_TO_WORD(STRING_TO_INT(KommCtrl.AStr));
        Properties.Status.InHome := AWordBoolArray[8]; 
        Properties.Status.MotorOn := AWordBoolArray[9]; 
        Properties.Status.PowerHigh := AWordBoolArray[10]; 
        Properties.Status.Automatik := AWordBoolArray[11]; 
                
        ALen := LEN(KommCtrl.RecStrProp)-45;
        // KommCtrl.RecStrProp Bsp.: 126,ACK,Properties,0000000000000020000000000,68.8883,-165.911,-26.5361,-26.9209,1,0,0,0,221.613,-38.1282,-26.5361,-210.406,1
        KommCtrl.TempStr := MID(in:=KommCtrl.RecStrProp, l:=(ALen), p:=46); // Feste Zeichenanzahl rausschmeißen        
        // KommCtrl.TempStr Bsp.: 68.8883,-165.911,-26.5361,-26.9209,1,0,0,0,221.613,-38.1282,-26.5361,-210.406,1
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // CurPos.X aus KommCtrl.TempStr ausschneiden Bsp.: 68.8883
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: -165.911,-26.5361,-26.9209,1,0,0,0,221.613,-38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: 68.8883 nach S7 real Format wandeln ±v.nnnnnnnE±xx                        
        NonS7StrToRealStr(InString:=KommCtrl.AStr);
        Properties.CurPos.X := STRING_TO_REAL(NonS7StrToRealStr.OutString);
                
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // CurPos.Y aus KommCtrl.TempStr ausschneiden Bsp.: 68.8883
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: -26.5361,-26.9209,1,0,0,0,221.613,-38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: -165.911 nach S7 real Format wandeln ±v.nnnnnnnE±xx                        
        NonS7StrToRealStr(InString:=KommCtrl.AStr);
        Properties.CurPos.Y := STRING_TO_REAL(NonS7StrToRealStr.OutString);      
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // CurPos.Z aus KommCtrl.TempStr ausschneiden Bsp.: 68.8883
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: -26.9209,1,0,0,0,221.613,-38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: -26.5361 nach S7 real Format wandeln ±v.nnnnnnnE±xx                        
        NonS7StrToRealStr(InString:=KommCtrl.AStr);
        Properties.CurPos.Z := STRING_TO_REAL(NonS7StrToRealStr.OutString);        
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // CurPos.U aus KommCtrl.TempStr ausschneiden Bsp.: 68.8883
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: 1,0,0,0,221.613,-38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: 26.9209 nach S7 real Format wandeln ±v.nnnnnnnE±xx                        
        NonS7StrToRealStr(InString:=KommCtrl.AStr);
        Properties.CurPos.U := STRING_TO_REAL(NonS7StrToRealStr.OutString);            
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // Merker aus KommCtrl.TempStr ausschneiden Bsp.: 99
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: 0,0,0,221.613,-38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: 1 nach Bool
        AWordForBool := INT_TO_WORD(STRING_TO_INT(KommCtrl.AStr));
        FOR i:=1 TO 8 DO // Merker 1-8
          Properties.Merker[i]                 := AWordBoolArray[i+7];
        END_FOR;             
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // HandLefty aus KommCtrl.TempStr ausschneiden Bsp.: 1
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: 0,0,221.613,-38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: 1 nach Bool
        IF STRING_TO_CHAR(KommCtrl.AStr) = '1' THEN
          Properties.CurPos.HandLefty := True;
        ELSE
          Properties.CurPos.HandLefty := False;
        END_IF;
   
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // J1Flag aus KommCtrl.TempStr ausschneiden Bsp.: 1
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: 0,221.613,-38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: 1 nach Bool           
        IF STRING_TO_CHAR(KommCtrl.AStr) = '1' THEN
          Properties.CurPos.J1Flag := True;
        ELSE
          Properties.CurPos.J1Flag := False;
        END_IF;        
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // J2Flag aus KommCtrl.TempStr ausschneiden Bsp.: 1
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: 221.613,-38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: 1 nach Bool           
        IF STRING_TO_CHAR(KommCtrl.AStr) = '1' THEN
          Properties.CurPos.J2Flag := True;
        ELSE
          Properties.CurPos.J2Flag := False;
        END_IF;         
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // CurPosW.J1 aus KommCtrl.TempStr ausschneiden Bsp.: 68.8883
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: -38.1282,-26.5361,-210.406,1
        // KommCtrl.AStr bsp.: 221.613 nach S7 real Format wandeln ±v.nnnnnnnE±xx                        
        NonS7StrToRealStr(InString:=KommCtrl.AStr);
        Properties.CurPosW.J1 := STRING_TO_REAL(NonS7StrToRealStr.OutString);          
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // CurPosW.J2 aus KommCtrl.TempStr ausschneiden Bsp.: 68.8883
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: -26.5361,-210.406,1
        // KommCtrl.AStr bsp.: -38.1282 nach S7 real Format wandeln ±v.nnnnnnnE±xx                        
        NonS7StrToRealStr(InString:=KommCtrl.AStr);
        Properties.CurPosW.J2 := STRING_TO_REAL(NonS7StrToRealStr.OutString);          
               
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // CurPosW.J3 aus KommCtrl.TempStr ausschneiden Bsp.: 68.8883
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: -210.406,1
        // KommCtrl.AStr bsp.: -26.5361 nach S7 real Format wandeln ±v.nnnnnnnE±xx                        
        NonS7StrToRealStr(InString:=KommCtrl.AStr);
        Properties.CurPosW.J3 := STRING_TO_REAL(NonS7StrToRealStr.OutString);        
        
        AInt := FIND(in1:=KommCtrl.TempStr, in2:=',');
        ALen := ALen - AInt;        
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=AInt-1, p:=1); // CurPosW.J4 aus KommCtrl.TempStr ausschneiden Bsp.: 68.8883
        KommCtrl.TempStr := MID(in:=KommCtrl.TempStr, l:=ALen, p:=AInt+1);
        // KommCtrl.TempStr Bsp.: 1
        // KommCtrl.AStr bsp.: -210.406 nach S7 real Format wandeln ±v.nnnnnnnE±xx                        
        NonS7StrToRealStr(InString:=KommCtrl.AStr);
        Properties.CurPosW.J4 := STRING_TO_REAL(NonS7StrToRealStr.OutString);         


        // Letztes Zeichen, hier kein Komma mehr
        KommCtrl.AStr := MID(in:=KommCtrl.TempStr, l:=1, p:=1); // InPos aus KommCtrl.TempStr ausschneiden Bsp.: 1
        // KommCtrl.AStr bsp.: 1 nach Bool                          
        IF STRING_TO_CHAR(KommCtrl.AStr) = '1' THEN
          Properties.Status.InPos := True;
        ELSE
          Properties.Status.InPos := False;
        END_IF;                                      
        Properties.Step   := 100;           
      END_IF;   
             
    100://Schrittkette beenden 
      Properties.Step         := 0; 
      Properties.IsError      := False;
      Properties.ErrorID      := 0;       
  END_CASE;
 

Similar threads

S
TIA AWL Probleme mit LD Zugriff in FC bei TIA V17
Antworten
14
Aufrufe
661
StallionP51
S
D
TIA SCL mit Variablen auf einen DB mit verschachtelten Strukturen zugreifen
Antworten
19
Aufrufe
775
DCDCDC
D
G
Step 7 UDT als IN_OUT (SCL)
Antworten
7
Aufrufe
931
Oberchefe
O
D
TIA SCL Anfänger
2
Antworten
23
Aufrufe
1K
Dekuika
Dekuika
D
Sonstiges PCS 7 Programmierfehler: 60 im OB31
Antworten
10
Aufrufe
825
Detto
D
Zurück
Oben