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

Ergebnis 1 bis 4 von 4

Thema: SCL Stringverarbeitung Lokaldaten

  1. #1
    Registriert seit
    08.03.2011
    Beiträge
    9
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    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
    Zitieren Zitieren SCL Stringverarbeitung Lokaldaten  

  2. #2
    Registriert seit
    01.10.2012
    Beiträge
    203
    Danke
    12
    Erhielt 56 Danke für 36 Beiträge

    Standard

    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?
    Nüchtern betrachtet war es besoffen besser.

  3. #3
    Barthiboy ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    08.03.2011
    Beiträge
    9
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    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;

  4. #4
    Barthiboy ist offline Neuer Benutzer
    Themenstarter
    Registriert seit
    08.03.2011
    Beiträge
    9
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


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

Ähnliche Themen

  1. Antworten: 16
    Letzter Beitrag: 06.02.2015, 10:25
  2. Stringverarbeitung, Zeichenkette
    Von qpec_hagen im Forum Simatic
    Antworten: 7
    Letzter Beitrag: 24.08.2012, 22:06
  3. Antworten: 22
    Letzter Beitrag: 04.09.2011, 15:34
  4. SCL: Lokaldaten des Vorgängerbausteins (87h)
    Von vierlagig im Forum Simatic
    Antworten: 13
    Letzter Beitrag: 01.06.2010, 19:13
  5. SCL und Lokaldaten
    Von derwestermann im Forum Simatic
    Antworten: 4
    Letzter Beitrag: 14.03.2008, 11:53

Lesezeichen

Berechtigungen

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