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

Seite 4 von 5 ErsteErste ... 2345 LetzteLetzte
Ergebnis 31 bis 40 von 45

Thema: Probleme mit SFC14 und 15 in SCL

  1. #31
    Registriert seit
    20.07.2012
    Beiträge
    33
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Ich habe die Funktion in einen FB umgewandelt jedoch wird mir nun der Fehler "Deklaration einer Aufrufinstanz oder verwendeter Parameterdatentyp in diesem Vereinbarungsblock nicht zulässig". Und zwar an dieser Stelle:


    Code:
        pAny_Quelle AT Pointer1: ANY;  
        pAny_Ziel AT Pointer2: ANY;
    Was hat es damit auf sich?


    Wie funktioniert das denn mit dem symbolischen ansprechen? Hast du da vielleicht mal ein Beispiel? Ich habe auch erst vor kurzem angefangen mit SCL zu programmieren und kenne mich da noch nicht so gut mit aus...


    Edit: Ich habe diese beiden nun in VAR_OUTPUT geschrieben und dadurch mal zumindest keinen Fehler mehr (ob das aber so richtig ist, weiß ich nicht). Jetzt wird mir beim FC "Tauschen" - "Fehler beim Zugriff auf den Baustein (offline) angezeigt
    Geändert von b.weyand85 (08.09.2014 um 14:40 Uhr)

  2. #32
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.794
    Danke
    398
    Erhielt 2.417 Danke für 2.013 Beiträge

    Standard

    ... die Deklaration des/der ANY-Pointer mußt du unter VAR_TEMP machen ...

    Wegen dem "symbolischen Ansprechen" : siehe z.B. mein Beitrag #27

    Gruß
    larry

  3. #33
    Registriert seit
    20.07.2012
    Beiträge
    33
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Mit VAR_TEMP funktioniert dies nicht. Wenn ich anstelle dessen VAR_INPUT benutze, dann werden alle 10 Programmsegmente übertragen. Ich kann die Werte dann auch erfolgreich abrufen. Wie ich diese abrufe soll an dieser Stelle nicht weiter interessieren.

    Mein Code sieht jetzt folgendermaßen aus:

    Code:
    FUNCTION_BLOCK FB1
    VAR
        erg: INT;  //Rückgabewert
        STROBEID_SPS, STROBEID_SINIUS, STROBE_ALT: INT;
        CMDID, RESULT: INT;
        S_CMD, ERRFLG, S_PROG_HOLEN, S_PROG_UEBERTRAGEN:BOOL; //Schalter Kommando ausführen, Errorflag, Schalter Programm übertragen
        PROGSEG, PROGSEG_SINIUS, SCHRITT : INT;
        QUELLE, ZIEL :INT;
        POINTER_UEBERTRAGEN :DINT;
    END_VAR
        VAR_INPUT
            Pointer1: STRUCT  //ANY Struktur 1 anlegen            
            ANY_id: BYTE;  
            Quelle_Datentyp: BYTE; 
            Quelle_Laenge: WORD;
            Quelle_DB_Nummer: WORD;
            Quelle_Byte_Pointer: DWORD;
            END_STRUCT;
        Pointer2: STRUCT  //ANY Struktur 2 anlegen
            ANY_id: BYTE;
            Ziel_Datentyp: BYTE;
            Ziel_Laenge: WORD;
            Ziel_DB_Nummer: WORD;
            Ziel_Byte_Pointer: DWORD;
            END_STRUCT;//Deklaration ANY Pointer für Quell-DB
        pAny_Quelle AT Pointer1: ANY;  
        //Deklaration ANY Pointer für Ziel-DB
        pAny_Ziel AT Pointer2: ANY;  
      
    END_VAR
    
    BEGIN
    CMDID := BYTE_TO_INT(DB1.DBB43);
    STROBEID_SPS := BYTE_TO_INT(DB1.DBB42);
    STROBEID_SINIUS := BYTE_TO_INT(DB1.DBB6);
    RESULT := BYTE_TO_INT(DB1.DBB7);
    S_CMD := DB2.DBX0.0;
    ERRFLG := DB1.DBX7.7;
    S_PROG_HOLEN := DB2.DBX0.1;
    S_PROG_UEBERTRAGEN := DB2.DBX0.2;             
    PROGSEG_SINIUS := BYTE_TO_INT(DB1.DBB9);
    
    IF S_PROG_UEBERTRAGEN = TRUE THEN
                Pointer1.ANY_id:= 16#10;  //Angabe der Syntax-ID
                Pointer1.Quelle_Datentyp:= 16#02; //Code für den Datentyp
                Pointer1.Quelle_Laenge:= 16#10;
                Pointer1.Quelle_DB_Nummer:= 16#06;                                    
                Pointer1.Quelle_Byte_Pointer:= dw#16#84000000; //Byte und Bitadresse des Datenbausteins hier 0.0
                //    -Speicherber.     -|  nix |-  Byteadresse    -|Bitadresse
                //dw#2#1000 (=8) 0100 (=4) 0000 0000 0000 0000 0101 0000                                                                          
                Pointer2.ANY_id:= 16#10;  //Vorbelegen der Ziel-ANY-Pointer Variablen
                Pointer2.Ziel_Datentyp:= 16#02;
                Pointer2.Ziel_Laenge:= 16#10;
                Pointer2.Ziel_DB_Nummer:= 16#01;
                //    -Speicherber.     -|  nix |-  Byteadresse    -|Bitadresse
                //dw#2#1000 (=8) 0100 (=4) 0000 0000 0000 0001 1000 0000 = 48.0 
                Pointer2.Ziel_Byte_Pointer:= dw#16#84000180;
                SCHRITT := 1;
                DB2.DBX0.2 := FALSE;            
    END_IF;
    
    
    CASE SCHRITT OF
            1:  
                PROGSEG := 0;
                DB1.DBB45 := INT_TO_BYTE(PROGSEG); 
                DB1.DBB43 := INT_TO_BYTE(6);//Kommando-ID auf 6 setzen: Programmsegment übertragen       
                Quelle := 20;
                Ziel := 0;
                Tauschen(X1:= DB6.DBW[Quelle], X3:= DB6.DBW[Ziel]); //HIGH- und LOW-Byte tauschen
                Quelle := Quelle +2;
                Ziel := Ziel +2;
                Tauschen(X1:= DB6.DBW[Quelle], X3:= DB6.DBW[Ziel]); //HIGH- und LOW-Byte tauschen
                Quelle := Quelle +2;
                Ziel := Ziel +2;
                Tauschen(X1:= DB6.DBW[Quelle], X3:= DB6.DBW[Ziel]); //HIGH- und LOW-Byte tauschen
                erg:= SFC20(srcblk:= pAny_Quelle, dstblk:= pAny_Ziel); //Aufruf von SFC20 Blockmove um Teile des Datenbausteins zu kopieren
    
                DB1.DBB45 := INT_TO_BYTE(PROGSEG);
                STROBEID_SPS := 1;
                DB1.DBB42 := INT_TO_BYTE(STROBEID_SPS);
                SCHRITT := 2;
    
                
            2:          
                IF STROBEID_SINIUS = STROBEID_SPS THEN
                SCHRITT := 3;
                END_IF;
            
            3:
                PROGSEG := 1;
                DB1.DBB45 := INT_TO_BYTE(PROGSEG);
                Quelle := Quelle + 28;
                Ziel := Ziel + 28;
                Tauschen(X1:= DB6.DBW[Quelle], X3:= DB6.DBW[Ziel]);
                Quelle := Quelle +2;
                Ziel := Ziel +2;
                Tauschen(X1:= DB6.DBW[Quelle], X3:= DB6.DBW[Ziel]); //HIGH- und LOW-Byte tauschen
                Quelle := Quelle +2;
                Ziel := Ziel +2;
                Tauschen(X1:= DB6.DBW[Quelle], X3:= DB6.DBW[Ziel]); //HIGH- und LOW-Byte tauschen
                //    -Speicherber.     -|  nix |-  Byteadresse    -|Bitadresse
                //dw#2#1000 (=8) 0100 (=4) 0000 0000 0000 0001 0000 0000 = 32.0
                Pointer1.Quelle_Byte_Pointer:= dw#16#84000100;
                erg:= SFC20(srcblk:= pAny_Quelle, dstblk:= pAny_Ziel); //Aufruf von SFC20 Blockmove um Teile des Datenbausteins zu kopieren
                STROBEID_SPS := 2;
                DB1.DBB42 := INT_TO_BYTE(STROBEID_SPS);
                SCHRITT := 4;
                
                
             4:
                IF STROBEID_SINIUS = STROBEID_SPS THEN
                SCHRITT := 5;
    ...
    Ich habe hier der Übersicht halber nur die ersten beiden Programmsegmente notiert. Insgesamt besteht die Schrittkette jetzt aus 21 Schritten und die Segmente werden schon recht schnell übertragen. Bis hierhin schonmal Danke für die Unterstützung.

    Kann man den Code denn noch reduzieren? Im Prinzip passiert hierbei immer das Gleiche - es ändern sich halt nur die Adressen zum Tauschen und Kopieren.
    Das mit dem symbolischen Ansprechen verstehe ich noch nicht so ganz.

  4. #34
    Registriert seit
    22.06.2009
    Ort
    Sassnitz
    Beiträge
    11.316
    Danke
    932
    Erhielt 3.329 Danke für 2.688 Beiträge

    Standard

    Hmm, wo anfangen?

    Zunächst mal Kritik:

    Du hast noch so viele Defizite, willst aber gleich das maximale Profi-Programm ...
    SCL hast Du erst vor kurzem angefangen, ANY noch nicht richtig verstanden, die Unterschiede zwischen FB und FC und Variablen-Speicherorte kennst Du nicht, die zyklische Arbeitsweise der SPS hast Du anscheinend auch noch nicht richtig verinnerlicht, in Schrittketten teilst Du die Schritte falsch ein ... das ist einfach zuviel zum Korrigieren und Helfen. Wir können hier nicht einen Lehrgang für Dich veranstalten um Dir die Basics der SPS-Programmierung beizubringen.

    Tut mir leid, daß ich Dich hiermit so runterziehe...
    Ich kann Dir nur empfehlen: lerne in kleineren Schritten, programmiere zunächst kleine überschaubare Programmteile und teste häufiger und verstehe, was dabei passiert.


    Ich schätze, der SPS-Stop wegen Zugriffsfehler auf Instanz-DB kam in Deinem Schritt 2 beim Lesen des DB6.DBW[Quelle], weil Du da, solange Schritt 2 auf die Weiterschaltung wartete, in jedem Zyklus unbegrenzt den Index Quelle erhöht hast und beim Lesen von DB6.DBW[Quelle] für den Aufruf von Tauschen(... kracht es dann wenn das Ende des DB6 erreicht ist ... Ganz davon abgesehen daß die Rückgabe an DB6.DBW[Ziel] auch ungewollt quer durch den DB6 schmiert. Und ganz davon abgesehen, daß Du wohl mächtig Glück hattest, wenn in Quelle und Ziel überhaupt noch Werte von vorher drinstanden.
    Zitat Zitat von b.weyand85 Beitrag anzeigen
    Code:
            2:
                PROGSEG := 1;
                DB1.DBB45 := INT_TO_BYTE(PROGSEG);
                Quelle := Quelle + 32;
                Ziel := Ziel + 32;
                Tauschen(X1:= DB6.DBW[Quelle], X3:= DB6.DBW[Ziel]);
                STROBEID_SPS := 2;
                DB1.DBB42 := INT_TO_BYTE(STROBEID_SPS);
                IF STROBEID_SPS = STROBEID_SINIUS THEN
                SCHRITT := SCHRITT + 1;
                END_IF;
    Übrigens kann man Übergabeparametern und Funktionen auch aussagekräftige Namen geben:
    Tauschen(IN:= DB6.DW[Quelle], OUT:= DB6.DW[Ziel]);
    liest sich viel besser als die Variante mit X1 und X3 (sind diese Namen aus einem Zufallsgenerator?)

    Statt SFC-Nummern kann man auch gerne die "sprechenden" symbolischen Namen benutzen.

    Mich irritiert die Schreibweise Deiner Absolut-Zugriffe wie DB1.DBB45, DB6.DBW[Quelle], ...
    Nach SCL-Dokumentation darf beim indizierten Zugriff auf Speicherbereiche der Adressangabe nach dem .D nur ein Größenpräfix X B W D folgen (also .DX .DB .DW .DD) Der SCL-Compiler scheint Deine undokumentierte Schreibweise jedoch zu schlucken - die solltest Du Dir aber besser wieder abgewöhnen. Irgendwann muß vielleicht mal jemand Code von Dir migrieren, der wird sich freuen über die viele nötige manuelle Nacharbeit ...

    Du springst dauernd zwischen symbolischer und absoluter Adressierung hin und her. Greifst nach Belieben absolut auf externe globale Adressen zu, gerne auch unnötigerweise mehrfach ... das wirst Du selber in wenigen Wochen nicht mehr verstehen, geschweige denn ein anderer Programmierer.


    Zu den ANY-Deklarationsproblemen:
    Siemens hat nicht vorgesehen, daß man ANY-Variablen in STAT ablegt. Möglicherweise meint Siemens, daß man ANY nicht speichern soll.
    ANY geht nur in VAR_INPUT, VAR_IN_OUT und VAR_TEMP. Wenn man ANY nicht in/aus dem Baustein übergeben will, dann gehört die Deklaration in VAR_TEMP, auch wenn TEMP kein Gedächtnis hat - ich würde niemals einen zusammengebastelten ANY aus dem Baustein entlassen und beim nächsten Durchlauf ungeprüft darauf vertrauen, daß er noch den selben Inhalt hat (womöglich nur um ein paar Zuweisungen zu sparen).

    Harald
    Es ist immer wieder überraschend, wie etwas plötzlich funktioniert, sobald man alles richtig macht.

    FAQ: Linkliste SIMATIC-Kommunikation über Ethernet

  5. #35
    Registriert seit
    22.06.2009
    Ort
    Sassnitz
    Beiträge
    11.316
    Danke
    932
    Erhielt 3.329 Danke für 2.688 Beiträge

    Standard

    ... und nun konstruktive Tips zum Bessermachen.

    Wenn Du Deine DB1 und DB6 etwa so strukturieren würdest:
    Code:
    DATA_BLOCK DB1
      STRUCT
        Send : STRUCT                       //der zu sendende Datensatz (16 Byte)
          W1 : WORD ;                       //siehe DB6
          W2 : WORD ;
          W3 : WORD ;
          Data : ARRAY [1 .. 10] OF BYTE ;
        END_STRUCT ;
        irgendwas : ARRAY [16 .. 100] OF BYTE ; //irgendwelche weiteren DB-Bytes
      END_STRUCT ;
    BEGIN
    END_DATA_BLOCK
    
    DATA_BLOCK DB6
      STRUCT
        DS : ARRAY [0 .. 9] OF STRUCT       //ein Array mit 10 Datensätzen
          Send : STRUCT                       //der zu sendende Datensatz (16 Byte)
            W1 : WORD ;                       //1. Wert mit H/L-Byte getauscht
            W2 : WORD ;                       //2. Wert mit H/L-Byte getauscht
            W3 : WORD ;                       //3. Wert mit H/L-Byte getauscht
            Data : ARRAY [1 .. 10] OF BYTE ;  //irgendwelche weiteren zu sendenden Datenbytes
          END_STRUCT ;
          Reserve1 : DWORD ;
          WQ1 : WORD ;                      //1. Wert wo H/L-Byte getauscht werden müssen
          WQ2 : WORD ;                      //2. Wert wo H/L-Byte getauscht werden müssen
          WQ3 : WORD ;                      //3. Wert wo H/L-Byte getauscht werden müssen
          Reserve2 : WORD ;
          Reserve3 : DWORD ;
        END_STRUCT ;
      END_STRUCT ;
    BEGIN
    END_DATA_BLOCK
    ... dann könntest Du den Code in Deinen Schritten schön symbolisch ohne jedes ANY-Gebastel so schreiben:
    Code:
    FUNCTION_BLOCK FBxxx
    ...
    BEGIN
    ...
    CASE SCHRITT OF
          1:
              progseg := 0 ;
              ...
              Tauschen(IN:= DB6.DS[0].WQ1, OUT:=DB6.DS[0].Send.W1); //HIGH- und LOW-Byte tauschen
              Tauschen(IN:= DB6.DS[0].WQ2, OUT:=DB6.DS[0].Send.W2); //HIGH- und LOW-Byte tauschen
              Tauschen(IN:= DB6.DS[0].WQ3, OUT:=DB6.DS[0].Send.W3); //HIGH- und LOW-Byte tauschen
              DB1.Send := DB6.DS[0].Send ;
    ...
          3:
              progseg := 1 ;
              ...
              Tauschen(IN:= DB6.DS[1].WQ1, OUT:=DB6.DS[1].Send.W1); //HIGH- und LOW-Byte tauschen
              Tauschen(IN:= DB6.DS[1].WQ2, OUT:=DB6.DS[1].Send.W2); //HIGH- und LOW-Byte tauschen
              Tauschen(IN:= DB6.DS[1].WQ3, OUT:=DB6.DS[1].Send.W3); //HIGH- und LOW-Byte tauschen
              DB1.Send := DB6.DS[1].Send ;
    Wenn man den nun übersichtlichen Code anschaut, dann sieht man relativ leicht, wo man den Code eines Schrittes als parametrierbaren Code zusammenfassen oder auslagern könnte - er unterscheidet sich je Schritt ja nur im Index des Datensatzes:
    Code:
              progseg := 0 ;
              ...
              Tauschen(IN:= DB6.DS[progseg].WQ1, OUT:=DB6.DS[progseg].Send.W1); //HIGH- und LOW-Byte tauschen
              Tauschen(IN:= DB6.DS[progseg].WQ2, OUT:=DB6.DS[progseg].Send.W2); //HIGH- und LOW-Byte tauschen
              Tauschen(IN:= DB6.DS[progseg].WQ3, OUT:=DB6.DS[progseg].Send.W3); //HIGH- und LOW-Byte tauschen
              DB1.Send := DB6.DS[progseg].Send ;
    Wenn Du das so aufbaust, dann kannst Du einen Schritt auch mehrmals durchlaufen, weil der variable Index im Schritt nicht relativ verändert wird.

    Für die Strukturen "Send" in DB1 und DB6 könntest Du auch einen UDT verwenden, dann mußt Du nur einmal beschreiben, wie die Struktur aussieht.

    Harald
    Es ist immer wieder überraschend, wie etwas plötzlich funktioniert, sobald man alles richtig macht.

    FAQ: Linkliste SIMATIC-Kommunikation über Ethernet

  6. #36
    Registriert seit
    20.07.2012
    Beiträge
    33
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Hi Harald,
    zuerst einmal danke für die konstruktive Kritik

    Die Basics zum SPS programmieren sollten bei mir eigentlich schon vorhanden sein. Wenn man aber 2 Jahre nichts mehr damit zu tun hatte, fällt es anfänglich etwas schwer dort wieder hinein zu kommen. Und wenn man vorher fast ausschließlich in FUP programmiert hat und nun mit SCL anfängt muss man sich auch dort erstmal zurecht finden. Dass dies hier nicht zu einem Lehrgang werden soll ist mir auch klar, deshalb werde ich mir in den nächsten Tagen das Buch „Automatisieren mit STEP 7 in AWL und SCL“ - von Hans Berger ausleihen und mir das zu Gemüte führen. Gibt es sonst noch Bücher oder andere Hilfsmittel, die jemand empfehlen kann?

    Mich irritiert die Schreibweise Deiner Absolut-Zugriffe wie DB1.DBB45, DB6.DBW[Quelle], ...
    Dies habe ich aus FUP übernommen wo der Any-Pointer z.B. mit P#DB1.DBX 0.0 Byte 100 deklariert wird. Dass dies anders geschrieben wird wusste ich nicht. Ich habe es demzufolge mal geändert. Auch den Tipp mit den Übergabeparametern und symbolischen Namen der SFC habe ich übernommen.

    Du springst dauernd zwischen symbolischer und absoluter Adressierung hin und her. Greifst nach Belieben absolut auf externe globale Adressen zu, gerne auch unnötigerweise mehrfach ... das wirst Du selber in wenigen Wochen nicht mehr verstehen, geschweige denn ein anderer Programmierer.
    Was meinst du damit genau? Was kann ich dabei besser machen?


    Zu deinem 2. Post:
    Also wenn ich die DBs direkt in SFC deklariere und so aufbaue, dann kann ich direkt auf die einzelnen Bytes/Wörter zugreifen und kann den ganzen Kram mit der ANY-Pointer-Deklaration weglassen?

  7. #37
    Registriert seit
    20.07.2012
    Beiträge
    33
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Ich habe mal den Tipp befolgt und das Programm umgeschrieben, so dass die Any-Pointer bei der Programmsegmentübertragung rausfallen dies funktioniert auch. Das ist schon eine schöne Sache, jedoch habe ich jetzt ein anderes Problem...

    Der DB1 ist dabei an DB6 angepasst zur Übertragung von Programmsegmenten. Bei Byte 4 der kommandospezifischen Daten (Kommando4) können allerdings verschiedene Modi durch setzen der jeweiligen Bits ausgewählt werden.

    Das mit der Zuweisung funktioniert ja nur, wenn die Struktur Send genauso aufgebaut ist, wie der Datensatz in DB6. Gibt es eine Möglichkeit Byte 4 in 7 Boolesche Werte aufzuteilen um weiterhin mit der Zuweisung arbeiten zu können?

    Das hier steht momentan in DB1

    Code:
        
    Send : STRUCT            //zu sendender Datensatz
            Kommando0 : WORD;   
            Kommando1 : WORD;       
            Kommando2 : WORD;      
            Kommando3 : BYTE;            
            Kommando4 : BYTE;
        END_STRUCT;
    Ich habe mir ungefähr so etwas in DB6 dann vorgestellt:

    Code:
    DATA_BLOCK DB6
      STRUCT  
        Segment : ARRAY [0 .. 9] OF STRUCT   //ein Array mit 10 Datensätzen
          Send : STRUCT                 //der zu sendende Datensatz 16 Byte              
            Kommando0 : WORD;           //Anfangsstrom I1 mit getauschtem HIGH- und LOW-Byte
            Kommando1 : WORD;           //Endstrom I2 mit getauschtem HIGH- und LOW-Byte
            Kommando2 : WORD;           //Schweißdauer mit getauschtem HIGH- und LOW-Byte
            Kommando3 : BYTE;           //Druck
          
          Flags : STRUCT
                KSR : BOOL;
                NOCOMP : BOOL;
                EXTSOLL : BOOL;
                NAHT : BOOL;
                EXTANALOG : BOOL;
                NC : BOOL;
                NC2: BOOL;
                MULTIWELD : BOOL;
          END_STRUCT;
          END_STRUCT;
    Beim kompilieren wird mir dann, verständlicherweise, an der Stelle:
    Code:
    DB1.SPS_an_Sinius.Send := DB6.Segment[1].Send;
    ungültiger Datentyp angezeigt.

    Weiterhin ist bei anderen Kommandos die Struktur der kommandospezifischen Daten anders aufgebaut als bei der Programmsegmentübertragung - vermutlich lässt sich das aber am besten über den SFC20 und die Verwendung von Any-Pointern lösen. Dabei ist die Struktur ja egal und es werden ohne Rücksicht auf Verluste die Bytes übertragen, die angegeben werden. Oder gibt es vielleicht doch noch eine andere Lösung?

  8. #38
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.794
    Danke
    398
    Erhielt 2.417 Danke für 2.013 Beiträge

    Standard

    Hallo,
    diese Zuweisung :
    Code:
    DB1.SPS_an_Sinius.Send := DB6.Segment[1].Send;
    ... funktioniert nur dann, wenn 1. die symbolischen Namen der DB's korrekt angelegt sind und auch so heißen und 2. der Quell- und der Zieldatentyp identisch sind - und zwar nicht nur von der Speicherbelegung her sondern komplett im Aufbau.

    Ich vermute, dass es erstmal so heißen müßte :
    Code:
    "DB1".SPS_an_Sinius.Send := "DB6".Segment[1].Send;
    Gruß
    Larry

  9. #39
    Registriert seit
    20.07.2012
    Beiträge
    33
    Danke
    0
    Erhielt 0 Danke für 0 Beiträge

    Standard

    Das funktioniert leider nicht. Mir wird dabei angezeigt, dass das globale Symbol nicht angezeigt wird. Was hat es damit auf sich?

    Edit:
    Ersteres hat sich erledigt - ich musste die Symbolnamen nehmen, die ich vergeben habe. Jedoch erscheint weiterhin die Meldung "Ungültiger Datentyp"...
    Geändert von b.weyand85 (22.09.2014 um 20:49 Uhr)

  10. #40
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.794
    Danke
    398
    Erhielt 2.417 Danke für 2.013 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Du mußt schon ALLES lesen, was ich geschrieben habe :
    Zitat Zitat von Larry Laffer Beitrag anzeigen
    ... und 2. der Quell- und der Zieldatentyp identisch sind - und zwar nicht nur von der Speicherbelegung her sondern komplett im Aufbau ...
    ... das heißt, das in beiden DB's die letzte Struktur vom gleichen Datentyp (UDT) sein müssen. Ansonsten mußt du dir auf einen der DB's eine AT-Sicht erstellen, die das wieder passend macht - die AT-Sicht dann aber für den kompletten DB ...

    Gruß
    Larry

Ähnliche Themen

  1. TIA Probleme mit s71200 und scl
    Von RMLIF im Forum Simatic
    Antworten: 13
    Letzter Beitrag: 09.10.2013, 15:25
  2. Korrekter Aufruf von DPWR_DAT (SFC14) in SCL?
    Von iga-graz im Forum Simatic
    Antworten: 7
    Letzter Beitrag: 25.03.2009, 15:24
  3. Probleme mit SCL
    Von Kubi im Forum CODESYS und IEC61131
    Antworten: 12
    Letzter Beitrag: 20.03.2009, 19:30
  4. Probleme mit DBs in SCL
    Von chrissi im Forum Simatic
    Antworten: 22
    Letzter Beitrag: 09.08.2007, 13:06
  5. Probleme mit 2 For Next Schleifen in SCL
    Von Gerold im Forum Simatic
    Antworten: 4
    Letzter Beitrag: 07.10.2005, 11:01

Lesezeichen

Berechtigungen

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