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

Seite 1 von 5 123 ... LetzteLetzte
Ergebnis 1 bis 10 von 50

Thema: Programmierwettbewerb

  1. #1
    Registriert seit
    30.10.2009
    Ort
    10 km vom Herzen der Natur
    Beiträge
    1.628
    Danke
    120
    Erhielt 340 Danke für 255 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hier der Thread für den lange diskutierten Programmierwettbewerb.

    Der Grundentwurf für die Regeln:
    Zitat Zitat von PN/DP Beitrag anzeigen
    Bitte fangt nicht an, die Lösungsmöglichkeiten zu sehr einzuschränken.
    Womöglich brauchen wird dann noch eine Abstimmung vorher, ob eine Aufgabe für den Wettbewerb überhaupt zugelassen wird?

    Es sollte eigentlich reichen, wenn die "Weiterschalt"-Schritte und -Fristen hier festgelegt werden.
    Wenn eine Programmlösung mehr als 200 Zeilen Code erfordert, dann sollte aus Rücksicht auf die "arbeitenden" Programmierer die Einreichungsfrist frühestens Montags enden, also ein Wochenende enthalten sein. Die Mindestlaufzeit einer Aufgabe sollte 3 bis 7 Tage sein (je nach Schwierigkeit der Aufgabe).


    Ich hatte mich schon mal vor längerer Zeit mit dem Gedanken an einen Programmierwettbewerb beschäftigt. Hier meine Zusammenfassung und ein paar Vorschläge als Diskussionsanregung.

    Programmiersystem/Step7-Version
    Ich gehe davon aus, daß hier Programmlösungen für Step7 "classic" V5.x gesucht werden sollen. Es ist einfach die verbreitetste Basis der im Forum vertretenen User. Die CodeSys-Leute und andere können bei Bedarf ja einen eigenen Wettbewerb veranstalten. (Vielleicht ergibt sich aber auch eine schöne Abwechslung, so daß nicht immer die selben User gewinnen. Wer weiß?)

    Die Programmlösung sollte in jeder Step7 "classic" Version einsetzbar sein (nagut, mindestens V5.4 und V5.5. Kann man in Step7 V5.5 überhaupt hardware-"unabhängige" Programme schreiben, die nicht mit V5.4 funktionieren?)
    Apropos: ich habe auch nur V5.4
    Doch auch das Programmiersystem sollte dem Aufgabensteller freigestellt sein. Wenn er explizit eine Lösung will, die mit TIA gelöst werden soll, dann muß er es halt hinschreiben (wegen der Forderung nach Veröffentlichung in Textform käme da wohl nur SCL in Frage).

    Mit welcher Programmiersprache eine Aufgabe gelöst werden soll, sollte der Aufgabensteller vorgeben. Auf jeden Fall muß es eine Sprache sein, die in Textform gepostet werden kann ist. (Man kann aber auch FUP/KOP-kompatiblen AWL-Code schreiben und dann die Ansicht umstellen). Es ist nicht zumutbar, daß man zur Prüfung einer Programmlösung erst einen Screenshot einer grafischen Programmiersprache nachprogrammieren muß. Und wenn jemand SCL zur Lösung verlangt, dann soll es eben so sein. Bekommt er eben weniger Feedback.

    Ob für eine Programmieraufgabe unbedingt ein gekapselter Baustein zu erstellen ist oder ein Codeschnipsel reicht, wird wohl von der Aufgabe abhängen. Für einen Vierzeiler wie z.B. der Test, ob ein DINT-Rechenergebnis in einen INT-Wert passt, sehe ich nicht ein, extra einen Baustein zu erzeugen. Sowas wäre eher als Inline-Makro zu sehen.
    Wenn die Aufteilung der Lösung auf mehrere Bausteine sinnvoll ist, warum eigentlich nicht? Es wird wohl sowieso weniger vorkommen, die Aufgabenlösungen sollten in wenigen Stunden bis max 1 Tag inklusive Test programmierbar sein.

    Eine Programmlösung oder zumindest ein prinzipieller Lösungsweg für die Aufgabenstellung sollte dem Aufgabensteller vorher bekannt sein. Erstens um den Aufwand abschätzen zu können und zweitens um die Hausaufgaben-Frager hier als Aufgabensteller auszuschließen. Der Gewinner einer Aufgabe sollte das Erstvorschlagsrecht für die nächste Aufgabe binnen 48 Stunden haben. Er kann aber schon eher auf sein Recht verzichten. Es sollte einen oder mehrere Moderatoren für den Wettbewerb geben, mit dem vor Veröffentlichung einer Aufgabe die Aufgabe per PN besprochen werden kann.
    Falls nötig, sollten in der Aufgabenstellung spezielle Test-Datensätze angegeben werden, mit denen die Lösung überprüft werden kann.

    ...

    Die Nutzung von SFB/SFC und Standard-Bausteinen aus den normalen Simatic-Bibliotheken (z.B. IEC-Funktionen, STRING- und Zeitfunktionen) würde ich nicht von vornherein ausschließen. Wenn es dem Aufgabensteller aber darauf ankommt, daß keine externen Bausteine verwendet werden dürfen, dann muß er es erwähnen. Die Nutzung von lizenzpflichtigen Bausteinen ist aber ausgeschlossen, einfach deshalb, weil dann nur jemand die Lösung überprüfen kann, wer diesen Baustein besitzt.

    Die Programmlösungen sollten so geschrieben sein, daß sie auf einer S7-300 laufen UND mit PLCSIM fehlerfrei simulierbar sind, was bedeutet, daß sie auch auf S7-400 funktionieren.
    HW-Konfig - mein Vorschlag: 315-2 PN/DP -2EH13 (erfordert Step7 V5.4 SP2)
    Eventuell könnte ich so eine CPU ans Internet hängen, damit auch User ohne reale CPU unabhängig reale Laufzeitmessungen machen können.
    Soll/Muß ein Programm spezielle Möglichkeiten einer S7-400 nutzen, so muß diese Forderung im Programmkommentar erwähnt werden und das Programm muß vor Ausführung des Codes prüfen, ob es auch tatsächlich auf einer S7-400 (oder kompatiblen CPU) ausgeführt wird.

    Die Programmlösungen müssen die Aufgabe selbstverständlich fehlerfrei erfüllen. Die Programmlösung muß mehrfach nacheinander ohne manuelle Eingriffe oder zusätzlich auszuführenden Programmcode ausführbar sein. Sind Einschränkungen im Wertebereich von Variablen vorhanden, dann muss die Einhaltung der Grenzwerte geprüft werden und zumindest diese Einschränkungen erwähnt werden. Die Programmlösung darf in keinem Fall zum STOP der CPU führen. Es darf kein OB121 (Programmierfehler-OB) zum Verhindern des CPU-Stop erforderlich sein, es sei denn, die Aufgabe ist tatsächlich nicht anders lösbar, dann muß aber der OB121 als Bestandteil der Lösung so ausprogrammiert sein, daß das Programm zu einem sinnvollen Ende kommt.
    Das Programm muß mit der Standard-HW-Konfig der CPU laufen (so wie Step7 diese CPU in ein leeres Rack einfügt), also z.B. nicht erfordern, daß die Zyklus-Überwachungszeit auf 10s eingestellt wird! Abweichungen von der Standard-HW-Konfig müssen in der Aufgabenstellung explizit erwähnt werden. Die CPU darf aber vernetzt werden, so wie es zum programmieren und beobachten erforderlich ist.

    Falls mehrere Programmlösungen kommen: Welches ist das "Beste Programm"?
    Da fallen mir gleich mehrere Kategorien ein, z.B.
    - kürzestes (MC7-Bedarf, ggf. Ladespeicherbedarf als zweites Kriterium) *
    - schnellstes (kann man messen) **
    - am besten lesbares/verständlichstes ***
    - ausgefallenstes/ungewöhnlichstes
    - Publikumsliebling

    * das Erzeugen von DB zur Laufzeit sollte nicht zur kosmetischen Programmverkleinerung benutzt werden. Und auch nicht positiv bewertet werden. Alle benötigten DB sollten beim Programmstart im Arbeitsspeicher vorhanden sein, das Vorhandensein der DB braucht nicht geprüft zu werden. Es sei denn, die Aufgabenstellung fordert das Anlegen von DB zur Laufzeit. Erwartete Anfangswerte in Variablen, die von 0/Leerstring/... verschieden sind, müssen zur Laufzeit initialisiert werden (je nach Aufgabe sind Ausnahmen möglich und sollten in der Aufgabenstellung erwähnt werden).

    ** für die Programmlaufzeit-Messung sollte hier ein verbindlicher Standard-Programmrahmen entwickelt werden, der für alle Aufgaben bzw. Lösungen benutzt wird und nicht Bestandteil der Lösung ist (dieser Zeitmess-Rahmen wäre z.B. eine Idee für eine der ersten Wettbewerbsaufgaben mit viel Diskussionspotential).

    *** weitestgehend benutzte symbolische Adressierung ist ein Pluspunkt
    Zeilenkommentare, die lediglich den AWL-Befehl in Umgangssprache wiederholen, werden als nicht vorhanden angesehen. (z.B.: L 27 //lade 27 in den AKKU1)
    Wordverknüpfungen, Schiebe- und Rotieroperationen würde ich nicht negativ bewerten, vor allem nicht, wenn im Zeilenkommentar das Ergebnis der Operation angegeben wird.

    Das "Beste Programm" sollte über eine Abstimmung gewählt werden (separate Threads), nicht über die Anzahl der Danke.
    Ein gut gewichtetes Punktesystem zur Bewertung der Lösung(en) fände ich ebenfalls gut.
    Und es sollte nur über Programme abgestimmt werden, die die Aufgabenstellung fehlerfrei erfüllen.
    Kommentare und Diskussionen zur Aufgabenstellung bitte nicht in diesem Thread sondern hier:
    http://www.sps-forum.de/showthread.php?t=46049
    Bitte hier nur Aufgabenstellungen und Lösungen posten (wenn in der Aufgabenstellung etwas unklar ist, darf natürlich auch hier nachgefragt und geantwortet werden).
    Die Gewinner werden auch hier bekannt gegeben.
    Geändert von M-Ott (17.06.2011 um 08:00 Uhr)
    Gruß
    Michael
    Zitieren Zitieren Programmierwettbewerb  

  2. #2
    M-Ott ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    30.10.2009
    Ort
    10 km vom Herzen der Natur
    Beiträge
    1.628
    Danke
    120
    Erhielt 340 Danke für 255 Beiträge

    Standard

    Zum Anfang was kleines:

    Es soll überprüft werden, ob ein WORD eine gültige BCD-Zahl enthält und somit fehlerfrei mit Hilfe von BTI in einen Integer-Wert umgewandelt werden kann.
    Am Ende soll ein BTI ausgeführt werden, wenn der Wert fehlerfrei umgewandelt werden kann, ansonsten soll "0" als Ersatzwert übergeben werden.
    Gruß
    Michael
    Zitieren Zitieren 1. Aufgabe  

  3. #3
    Registriert seit
    08.08.2007
    Ort
    Dresden
    Beiträge
    9.648
    Danke
    1.059
    Erhielt 2.046 Danke für 1.627 Beiträge

    Standard

    Code:
    *
    FUNCTION FC 444 : VOID
    TITLE =
    //Wandlung eines BCD-WORD in INT
    //wenn die Wandlung nicht möglich ist wird 0 ausgegeben. 
    VERSION : 0.1
    
    
    VAR_INPUT
      wIn : WORD ;	
    END_VAR
    VAR_OUTPUT
      iOut : INT ;	
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    
          L     #wIn; //lade Eingangswort
          BTI   ; //versuche in INT zu wandeln
          SPU   not; //wandlung nicht möglich? -> not
          SPA   end; //wandlung möglich -> end
    not:  L     0; //ersatzwert 0 laden
    end:  T     #iOut; //Ausgang beschreiben
    
    END_FUNCTION
    jetzt getestet -> erfordert OB121
    Geändert von vierlagig (16.06.2011 um 10:24 Uhr)
    [SIGNATUR]
    Ironie setzt Intelligenz beim Empfänger voraus.
    [/SIGNATUR]

  4. Folgende 3 Benutzer sagen Danke zu vierlagig für den nützlichen Beitrag:

    Cerberus (16.06.2011),Larry Laffer (17.06.2011),rostiger Nagel (16.06.2011)

  5. #4
    M-Ott ist offline Erfahrener Benutzer
    Themenstarter
    Registriert seit
    30.10.2009
    Ort
    10 km vom Herzen der Natur
    Beiträge
    1.628
    Danke
    120
    Erhielt 340 Danke für 255 Beiträge

    Standard

    @4L
    Ohne OB121: STOP
    Wenn's so einfach wäre, hätte ich die Aufgabe nicht gestellt.
    Gruß
    Michael

  6. #5
    Registriert seit
    22.03.2007
    Ort
    Detmold (im Lipperland)
    Beiträge
    11.786
    Danke
    398
    Erhielt 2.414 Danke für 2.010 Beiträge

    Standard

    Ich würde es so machen :
    Code:
    FUNCTION FC 100 : VOID
    TITLE =BCD to INT
    VERSION : 0.1
     
    VAR_INPUT
      InBCD : WORD ; 
    END_VAR
    VAR_OUTPUT
      Ergebnis : INT ; 
    END_VAR
    BEGIN
    NETWORK
    TITLE = 
    // Wandlung eines BCD-WORD in INT
    // Ist der Übergabewert illegal (Wandlung nicht möglich) wird 0 ausgegeben. 
     
    // 1. (niedrigstes) Nibble ausmaskieren
          L     #InBCD; 
          L     W#16#F; 
          UW    ; 
          L     9; 
          >I    ; 
          SPB   Err; // wenn > 9 dann illegal
    // 2. (mittleres) Nibble ausmaskieren
          L     #InBCD; 
          SRW   4; 
          L     W#16#F; 
          UW    ; 
          L     9; 
          >I    ; 
          SPB   Err; // wenn > 9 dann illegal
    // 3. (oberstes) Nibble ausmaskieren
          L     #InBCD; 
          SRW   8; 
          L     W#16#F; 
          UW    ; 
          L     9; 
          >I    ; 
          SPB   Err; // wenn > 9 dann illegal
    // 4. (Vorzeichen-) Nibble ausmaskieren 
    //    wenn Vorzeichen dann ist das höchste Bit gesetzt (= w#16#8000) sonst Null
          L     #InBCD; 
          L     W#16#7000; // alle Bits außer dem Vorzeichen-Bit ausmaskieren
          UW    ; 
          SPN   Err; // wenn > 0 dann illegal
          L     #InBCD; 
          BTI   ; 
          SPA   Ausg; 
    Err:  L     0; 
    Ausg: T     #Ergebnis; 
    END_FUNCTION
    ... aber daran läßt sich mit Sicherheit so Einiges an Zeilen einsparen ...

    Gruß
    Larry

  7. Folgender Benutzer sagt Danke zu Larry Laffer für den nützlichen Beitrag:

    rostiger Nagel (16.06.2011)

  8. #6
    Registriert seit
    28.02.2006
    Ort
    Ostsee 5 min zum Strand
    Beiträge
    780
    Danke
    92
    Erhielt 110 Danke für 98 Beiträge

    Standard

    Probieren muss ich es auch mal

    Code:
    FUNCTION FC 1 : VOID
    TITLE =BCD to INT
    VERSION : 0.1
    
    
    VAR_INPUT
      inWORD : WORD ;    
    END_VAR
    VAR_OUTPUT
      outINT : INT ;    
    END_VAR
    BEGIN
    NETWORK
    TITLE =WORD auf korrekte BCD prüfen und wandeln in INT
    //Durch das Schieben werden die restlichen Bits mit 0 aufgefüllt
    //Vorzeichen Nibbel abfragen
          L     #inWORD; //BCD Word als IN
          SRW   12; //Bit 12-15 nach Rechts schieben und auf Bit 0-3 
          L     0; //Abfrage grösser 0
          >I    ; 
          SPB   err; //wenn grösser - Fehler
    
    //Oberstes Nibbel abfragen
          L     #inWORD; //BCD Word als IN
          SLW   4; //Bit 0-11 nach Links schieben
          SRW   12; //Bit 12-15 nach Rechts schieben auf Bit 0-3
          L     9; //Abfrage grösser 9
          >I    ; 
          SPB   err; //wenn grösser - Fehler
    
    //Mittleres Nibbel abfragen
          L     #inWORD; //BCD Word als IN
          SLW   8; //Bit 0-7 nach Links schieben
          SRW   12; //Bit 12-15 nach Rechts schieben auf Bit 0-3
          L     9; //Abfrage grösser 9
          >I    ; 
          SPB   err; //wenn grösser - Fehler
    
    //Unteres Nibbel abfragen
          L     #inWORD; //BCD Word als IN
          SLW   12; //Bit 0-4 nach Links schieben
          SRW   12; //Bit 12-15 nach Rechts schieben auf Bit 0-3
          L     9; //Abfrage grösser 9
          >I    ; 
          SPB   err; //wenn grösser - Fehler
    
    //BCD ist korrekt
          L     #inWORD; //BCD Word als IN
          BTI   ; //BCD in Ganzezahl wandeln   
          SPA   _go; 
    
    err:  L     0; //wenn Fehler Lade 0
    _go:  T     #outINT; //INT als Out
         
    END_FUNCTION
    Gruß von der Ostsee

    Nordischerjung
    _____________________

    Wenn man seinem Paßbild ähnlich zu sehen beginnt, sollte man schleunigst Urlaub machen. (Vico Torriani, schw. Entertainer)

    Ich habe eine Diät gemacht und fettem Essen und Alkohol abgeschworen - in zwei Wochen verlor ich 14 Tage. (Joe E. Lewis)

  9. Folgender Benutzer sagt Danke zu Nordischerjung für den nützlichen Beitrag:

    rostiger Nagel (16.06.2011)

  10. #7
    Registriert seit
    23.10.2009
    Beiträge
    398
    Danke
    59
    Erhielt 114 Danke für 88 Beiträge

    Standard

    Hier kommt ein Werk von mir:
    Code:
    FUNCTION "TestBCD" : VOID
    TITLE =BCD-Word auf Gültigkeit testen und wandeln in INT
    //wenn der BCD-Wert illegal ist, wird als Ersatzwert 0 ausgegeben
    VERSION : 0.1
    
    VAR_INPUT
      inBCD : WORD ;    //BC-Zahl
    END_VAR
    VAR_OUTPUT
      outINT : INT ;    //Integer in Binärdarstellung
    END_VAR
    BEGIN
    NETWORK
    TITLE =
    
          L     #inBCD; 
          UW    W#16#7000; // Illegales Bit im Vorzeichen-Nibble?
          SPP   BAD; // Ja
          L     #inBCD; // Nein
          UW    W#16#888; // achter-Bits als Maske 
          SRW   1; // auf vierer-Bits schieben
          L     #inBCD; 
          UW    W#16#888; // achter-Bits als Maske
          SRW   2; // auf zweier-Bits schieben
          OW    ; // Achter-Maske für Zweier- und Vierer-Bits
          L     #inBCD; 
          UW    ; // Wenn Achter-Bit und (Zweier oder Vierer-Bit)
          SPP   BAD; // dann Illegale Zahl
          L     #inBCD; // legale BCD-Zahl
          BTI   ; // also wandeln
          SPA   GOOD; // und ausgeben
    BAD:  L     0; // Fehler, Ersatzwert
    GOOD: T     #outINT; // ausgeben
    END_FUNCTION
    Gruß
    Erich
    (der bald in Urlaub fährt)
    Geändert von LargoD (16.06.2011 um 16:15 Uhr) Grund: BE entfernt

  11. Folgende 8 Benutzer sagen Danke zu LargoD für den nützlichen Beitrag:

    dalbi (20.06.2011),Der Pfälzer (21.06.2011),eNDe (16.06.2011),M-Ott (17.06.2011),PN/DP (17.06.2011),rostiger Nagel (16.06.2011),Toki0604 (21.06.2011),vierlagig (16.06.2011)

  12. #8
    Registriert seit
    11.05.2005
    Ort
    Baden-Württemberg
    Beiträge
    673
    Danke
    113
    Erhielt 153 Danke für 124 Beiträge

    Standard

    mal was mit Schleife:

    Code:
    FUNCTION "CHECK BTI" : VOID
    TITLE =Prüfung, ob BTI für das Eingangswort möglich ist
    //Wandelt den Eingang wenn möglich mit BTI in eine Ganzzahl um.
    //Passt der Eingang nicht, dann wird 0 ausgegeben.
    //Der Fehlerausgang wird dann auf TRUE gesetzt.
    AUTHOR : Micha
    FAMILY : CHK
    NAME : CHK_BTI
    VERSION : 1.0
     
    VAR_INPUT
      BCD : WORD ; //Zu prüfendes Wort welches mit BTI gewandelt werden soll
    END_VAR
    VAR_OUTPUT
      QINT : INT ; //Ergebnis der Wandlung zur Ganzzahl
      QERR : BOOL ; //=1: Eingangswert nicht wandelbar
    END_VAR
    VAR_TEMP
      tiLC : INT ; 
      twSPEICHER : WORD ; 
    END_VAR
    BEGIN
    NETWORK
    TITLE =Logik
    //Die 3-stellige BCD Zahl wird in Maximal 3 Schleifendurchläufen gecheckt.
    //Ist ein Nibble größer 9, wird Fehler (QERR=TRUE) und 0 als Ersatzwert (QINT=0) 
    //ausgegeben.
          L     #BCD; 
          T     #twSPEICHER; 
          L     3; //Maximal 3 Durchläufe der Schleife
    L1:   T     #tiLC; 
          L     W#16#9; 
          L     #twSPEICHER; 
          UW    W#16#F; //schleifenabhängig Nibbles ausmaskieren
          -I    ; 
          SPM   ERR; //Wert des Nibbles >9 -> keine Wandlung möglich
          L     #twSPEICHER; //nächste 4 Bit laden
          SRW   4; 
          T     #twSPEICHER; 
          L     #tiLC; 
          LOOP  L1; 
    NETWORK
    TITLE =Ausgang
    //Ausgänge ansteuern
          CLR   ; 
          L     #BCD; 
          BTI   ; 
          SPA   AUSG; 
    ERR:  SET   ; 
          L     0; 
    AUSG: =     #QERR; 
          T     #QINT; 
    END_FUNCTION
    "arbeite klug, nicht hart" - deutsches Sprichwort

  13. Folgende 3 Benutzer sagen Danke zu SPSKILLER für den nützlichen Beitrag:

    Nordischerjung (17.06.2011),rostiger Nagel (17.06.2011),vierlagig (16.06.2011)

  14. #9
    Registriert seit
    30.03.2005
    Beiträge
    2.096
    Danke
    0
    Erhielt 673 Danke für 541 Beiträge

    Standard

    Die Diskussion zum Programmierwettbewerb geht hier weiter:

    http://www.sps-forum.de/showthread.php?t=46049

    Gruß Kai

  15. #10
    Registriert seit
    22.06.2009
    Ort
    Sassnitz
    Beiträge
    11.293
    Danke
    932
    Erhielt 3.320 Danke für 2.682 Beiträge

    Standard


    Zuviel Werbung?
    -> Hier kostenlos registrieren
    Hier meine Lösung:
    Code:
    FUNCTION "BCD2INT" : INT
    TITLE =BCD to INT
    AUTHOR : PN_DP
    FAMILY : SPSforum
    NAME : BCD2INT
    VERSION : 0.1
    
    VAR_INPUT
      InBCD : WORD ;	
    END_VAR
    BEGIN
    NETWORK
    TITLE =Wandlung eines BCD-WORD in INT
    //Ist der Eingangswert illegal (Wandlung nicht möglich!) wird 0 ausgegeben. 
    //Jede mögliche Bitfolge der Vorzeichen-Tetrade wird als korrekt akzeptiert,
    //für das Vorzeichen ist einzig das Bit 15 relevant.
    //
    //Auszug Step7 Hilfe zu AWL:   BTI   BCD wandeln in Ganzzahl (16 Bit)
    //"Bit 0 bis Bit 11 geben den Wert und Bit 15 das Vorzeichen (0 = positiv, 
    //1 = negativ) der BCD-Zahl an. Bit 12 bis Bit 14 werden bei der Umwandlung 
    //nicht verwendet."
    //Echte CPU (zB. 315-2EH13 V2.6 und 414-2XG03 V3.0.2) verhalten sich auch so.
    //Doch PLCSIM (V5.4.3) interpretiert JEDE Vorzeichentetrade <> 0 als negativ!
    //Deshalb werden hier als Bugfix für PLCSIM die Bit 12 bis 14 auf 0 gesetzt.
    
          L     W#16#9990;       // Prüfwert
          L     #InBCD;          // VVVV_HHHH_ZZZZ_EEEE
    
    // Hunderterstelle prüfen, dazu Vorzeichen entfernen
          SLW   4;               // HHHH_ZZZZ_EEEE_0000
          <D    ; 
          SPB   Err;             // Hunderter zu groß
    
    // Zehnerstelle prüfen, dazu Hunderterstelle entfernen
          SLW   4;               // ZZZZ_EEEE_0000_0000
          <D    ; 
          SPB   Err;             // Zehner zu groß
    
    // Einerstelle prüfen, dazu Zehnerstelle entfernen
          SLW   4;               // EEEE_0000_0000_0000
          <D    ; 
          SPB   Err;             // Einer zu groß
    
    // Eingabewert ist im gültigen Format -> in INT wandeln
          L     #InBCD; 
          UW    W#16#8FFF;       // Vorzeichen-Bugfix für PLCSIM
          BTI   ; 
          SPA   Ausg;            // hier ist immer VKE=1
    
    // Eingabewert ist ungültig -> 0 ausgeben
    Err:  L     0;               // Fehler-Ersatz-Ausgabewert
          CLR   ;                // VKE=0 für BIE/ENO Fehlerstatus
    
    Ausg: T     #RET_VAL;        // Ergebnis
          SAVE  ;                // Fehlerstatus im BIE speichern
    
    END_FUNCTION
    Harald
    Es ist immer wieder überraschend, wie etwas plötzlich funktioniert, sobald man alles richtig macht.

    FAQ: Linkliste SIMATIC-Kommunikation über Ethernet

  16. Folgende 2 Benutzer sagen Danke zu PN/DP für den nützlichen Beitrag:

    MW (21.06.2011),rostiger Nagel (17.06.2011)

Ähnliche Themen

  1. Programmierwettbewerb, 2. Aufgabe
    Von LargoD im Forum Stammtisch
    Antworten: 14
    Letzter Beitrag: 02.08.2011, 22:27
  2. Programmierwettbewerb: Diskussion
    Von Kai im Forum Stammtisch
    Antworten: 51
    Letzter Beitrag: 20.06.2011, 10:05
  3. Programmierwettbewerb: Interesse? Regeln!
    Von M-Ott im Forum Stammtisch
    Antworten: 67
    Letzter Beitrag: 18.06.2011, 08:28

Lesezeichen

Berechtigungen

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