# Programmierwettbewerb



## M-Ott (16 Juni 2011)

Hier der Thread für den lange diskutierten Programmierwettbewerb.

Der Grundentwurf für die Regeln:


PN/DP schrieb:


> 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.
> ...


 
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.


----------



## M-Ott (16 Juni 2011)

*1. Aufgabe*

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.


----------



## vierlagig (16 Juni 2011)

```
*
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


----------



## M-Ott (16 Juni 2011)

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


----------



## Larry Laffer (16 Juni 2011)

Ich würde es so machen :
	
	



```
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


----------



## Nordischerjung (16 Juni 2011)

Probieren muss ich es auch mal 


```
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
```


----------



## LargoD (16 Juni 2011)

Hier kommt ein Werk von mir:

```
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)


----------



## SPSKILLER (16 Juni 2011)

mal was mit Schleife:


```
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
```


----------



## Kai (16 Juni 2011)

Die Diskussion zum Programmierwettbewerb geht hier weiter:

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

Gruß Kai


----------



## PN/DP (17 Juni 2011)

Hier meine Lösung:

```
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


----------



## PN/DP (17 Juni 2011)

Hier mal eine Variante der BCD-zu-INT-Wandlung mit Eingangswert-Prüfung ohne CPU-STOP für die FUP/KOP-Freunde. 
Doch ob diese Variante schneller zu verstehen ist als meine AWL-Variante in #10?

```
FUNCTION "BCD2INTG" : INT
TITLE =BCD zu INT (FUP/KOP)
AUTHOR : PN_DP
FAMILY : SPSforum
NAME : BCD2INTG
VERSION : 0.2

VAR_INPUT
  InBCD : WORD ;	
END_VAR
VAR_TEMP
  TH_1 : BOOL ;	
  TH_2 : BOOL ;	
  TH_4 : BOOL ;	
  TH_8 : BOOL ;	
  TV_1 : BOOL ;	
  TV_2 : BOOL ;	
  TV_4 : BOOL ;	
  TV_8 : BOOL ;	
  TE_1 : BOOL ;	
  TE_2 : BOOL ;	
  TE_4 : BOOL ;	
  TE_8 : BOOL ;	
  TZ_1 : BOOL ;	
  TZ_2 : BOOL ;	
  TZ_4 : BOOL ;	
  TZ_8 : BOOL ;	
END_VAR
BEGIN
NETWORK
TITLE =Eingabewert in Testword kopieren

      L     #InBCD; 
      T     LW     0; 
      NOP   0; 
NETWORK
TITLE =Prüfung und Umwandlung BCD zu INT

      U(    ; 
      O     #TE_2; 
      O     #TE_4; 
      )     ; 
      U     #TE_8; 
      O     ; 
      U(    ; 
      O     #TZ_2; 
      O     #TZ_4; 
      )     ; 
      U     #TZ_8; 
      O     ; 
      U(    ; 
      O     #TH_2; 
      O     #TH_4; 
      )     ; 
      U     #TH_8; 
      =     L      2.0; 
      U     L      2.0; 
      SPBNB _001; 
      L     0; 
      T     #RET_VAL; 
_001: NOP   0; 
      U     L      2.0; 
      NOT   ; 
      =     L      2.1; 
      U     L      2.1; 
      SPBNB _002; 
      L     #InBCD; 
      L     W#16#8FFF; 
      UW    ; 
      T     LW     0; 
_002: NOP   0; 
      U     L      2.1; 
      SPBNB _003; 
      L     LW     0; 
      BTI   ; 
      T     #RET_VAL; 
_003: NOP   0; 

END_FUNCTION
```
Wenn man für das Testword statt TEMP (LW0) ein Schmier-Merkerword (z.B. MW100) benutzt, dann ist das Programm auch voll symbolisch möglich, weil dann den Testbits UND dem Testword ein symbolischer Name gegeben werden kann.

Harald


----------



## Kwas (17 Juni 2011)

[FONT=Arial, sans-serif]Hallo alle zusammen!

Meine Frage ist wie folgt:
Besteht die Möglichkeit das BCD -> INT in SCL, ohne Wandelfunktion (BCD_TO_INT) ausgeführt werden kann?[/FONT]


----------



## Larry Laffer (17 Juni 2011)

Hallo,
diese Frage hat in diesem Thread eigentlich gar nichts zu suchen - da sie nun aber schon einmal da ist ...
Ich weiß nicht genau, was du bezweckst und kann das aus der Frage auch nicht so recht ableiten ... aber generell kann man jeden komplexeren Befehl (siehe auch die vorhandenen Beispiele) auch selbst nachbilden. Und das geht dann natürlich auch in SCL ... 

Gruß
Larry


----------



## Kwas (17 Juni 2011)

Hallo,  
 und vielen Dank für so volles und umfangreiches Antworten.  
 Es wäre auch erfreulich mit solch einem Wissen, ein Beispiel gezeigt zu bekommen.
 :TOOL:


----------



## Toki0604 (18 Juni 2011)

*Baustein generieren aus AWL-Quelle*

An die Cracks unter euch,

Ich möchte gerne "mitmachen", aber ich habe ein Problem damit die Quellcodes aus dem Stehgreif zu verstehen.
Daher wollte ich die geposteten Quellcodes als AWL-Quelle in ein Projekt einfügen und damit den Baustein generieren. 
(Um dann mit PLC-SIM z.B. online zu beobachten)
Bekomme aber immer beim Übersetzen die Fehlermeldung das die Variablendeklaration oder Eintrag in der Symboltabelle fehlt (*Frust*).
Habe ich einen Gedankenfehler oder geht das nicht so einfach...

Dank im voraus,
Gruß
Toki


----------



## SPSKILLER (18 Juni 2011)

Hi,

einfach in der Symbolik einen Baustein mit dem richtigen Namen definieren. 
Der steht in der ersten Zeile der Quellen. 
Dann kannst du die FC Nummer frei vergeben. 

Alternativ kannst du auch den Namen in der Quelle (inclusive ") durch z.B. FC 1 ersetzen. 

Micha


----------



## dalbi (18 Juni 2011)

Hi,

hier meine Version in SCL 


```
FUNCTION BCD2INT : INT
TITLE = 'BCD nach INT'
//
// wandelt BCD Zahl (WORD) in Integer
//
VERSION : '1.0'
AUTHOR  : dalbi

VAR_INPUT
  InBCD : WORD;
END_VAR

VAR_TEMP
  i : INT;
  tINT : INT;
END_VAR
  
BEGIN

  FOR i := 0 TO 3 DO 
    // Nibble (4 Bit) aus WORD extrahieren
    tINT := WORD_TO_INT(SHR(IN := InBCD, N := i*4) AND W#16#000F);

    // Prüfen auf gültige BCD-Zahl 0..9
    IF tINT > 9 THEN 
      BCD2INT := 0;
      RETURN;
    END_IF;
    
    // BCD-Zahl in Integer wandeln
    CASE i OF
      0 : BCD2INT := tINT;
      1 : BCD2INT := BCD2INT + tINT * 10;
      2 : BCD2INT := BCD2INT + tINT * 100;
      3 : BCD2INT := BCD2INT + tINT * 1000;
    END_CASE;
  END_FOR;

END_FUNCTION
```

Gruss Daniel


----------



## Kwas (18 Juni 2011)

Danke Dalbi.


----------



## LargoD (18 Juni 2011)

1. Vorzeichen nicht behandelt
2. Den Case-Block brauchst Du nicht wenn Du vor der Schleife
BCD2INT auf Null setzt und dann statt des Case-Block schreibst

```
BCD2INT:= BCD2INT*10+tINT;
```
Gruß
Erich


----------



## Jochen Kühner (18 Juni 2011)

LargoD schrieb:


> 2. Den Case-Block brauchst Du nicht wenn Du vor der Schleife
> BCD2INT auf Null setzt und dann statt des Case-Block schreibst
> 
> ```
> ...



dacht ich auch erst, aber er multipliziert ja tInt und nicht Bcd2int, d.h. Man muss die schleife auch noch anderstrum durchlaufen...


----------



## LargoD (18 Juni 2011)

Stimmt!
Also zusätzlich noch die Schleife vom großen zum kleinen Index laufen lassen.

```
FOR i := 2 TO 0 BY -1 DO
```
2 stat 3 wegen Vorzeichen Nibble, das muss gesondert behandelt werden.
Gruß
Erich


----------



## Kwas (18 Juni 2011)

[FONT=Arial, sans-serif]Hi, Dalbi.
Ich versuchte dein FC austesten, aber traf folgende Problem an.(Sehe Anhang)

Was könnte fehlen?



Mein vorschlag zu Case-ersatz wehre:

BCD2INT:=BCD2INT+tINT*(10**i);

ps: nicht getestet [/FONT]


----------



## dalbi (18 Juni 2011)

Jochen Kühner schrieb:


> dacht ich auch erst, aber er multipliziert ja tInt und nicht Bcd2int, d.h. Man muss die schleife auch noch anderstrum durchlaufen...



Wieso? Geht doch so wie es ist. (siehe SHR)

Gruss Daniel


----------



## dalbi (18 Juni 2011)

Kwas schrieb:


> [FONT=Arial, sans-serif]Hi, Dalbi.
> Ich versuchte dein FC austesten, aber traf folgende Problem an.(Sehe Anhang)
> 
> Was könnte fehlen?
> ...



Du musst noch "BCD2INT" in die Symboltabelle eintragen.
z.B.  BCD2INT (FC1)

Gruss Daniel


----------



## Jochen Kühner (18 Juni 2011)

dalbi schrieb:


> Wieso? Geht doch so wie es ist. (siehe SHR)
> 
> Gruss Daniel



Es ging drum wenn die Änderung eingebaut wird! (ohne case)


----------



## Jochen Kühner (18 Juni 2011)

dalbi schrieb:


> Hi,
> 
> hier meine Version in SCL
> 
> ...



In der Aufgabenstellung hies es auch das BTI verwendet werden soll, also ist das eigendlich keine Lösung der Aufgabe (aber des Problems)


----------



## LargoD (18 Juni 2011)

Hier mal die Parallelbitprüfung in SCL


```
FUNCTION BCD2INT2 : INT
VAR_INPUT
  inBCD : WORD;
END_VAR
BEGIN
  IF ((SHR(in:=inBCD AND 16#888,N:=1) OR SHR(in:=inBCD AND 16#888,N:=2)) AND inBCD) = 0 THEN
    BCD2INT2 := BCD_TO_INT(IN:=inBCD);
  ELSE
    BCD2INT2 := 0;
  END_IF;
END_FUNCTION
```
Gruß
Erich


----------



## dalbi (18 Juni 2011)

Hi,

so jetzt will ich auch mal in AWL .


```
FUNCTION FC 2 : INT
TITLE =BCD TO INT
VERSION : 1.0
AUTHOR : dalbi

VAR_INPUT
  InBCD : WORD ;    
END_VAR
VAR_TEMP
  RetVal : INT ;            //Rückgabewert SFC36/37
  PRGFLT_MASKED : DWORD ;    //Maskierte Programmierfehler
  ACCFLT_MASKED : DWORD ;    //Maskierte Zugriffsfehler
END_VAR
BEGIN
NETWORK
TITLE =Synchronfehlerereignisse maskieren SFC 36 "MSK_FLT"

      CALL SFC   36 (
           PRGFLT_SET_MASK          := DW#16#2,// BCD-Wandlungsfehler
           ACCFLT_SET_MASK          := DW#16#0,
           RET_VAL                  := #RetVal,
           PRGFLT_MASKED            := #PRGFLT_MASKED,
           ACCFLT_MASKED            := #ACCFLT_MASKED);

NETWORK
TITLE =Wandlung durchführen

      L     #InBCD; 
      BTI   ; 
      T     #RET_VAL; 

NETWORK
TITLE =Synchronfehlerereignisse demaskieren SFC 37 "DMSK_FLT"

      CALL SFC   37 (
           PRGFLT_RESET_MASK        := DW#16#2,// BCD-Wandlungsfehler
           ACCFLT_RESET_MASK        := DW#16#0,
           RET_VAL                  := #RetVal,
           PRGFLT_MASKED            := #PRGFLT_MASKED,
           ACCFLT_MASKED            := #ACCFLT_MASKED);

END_FUNCTION
```

ohne CPU Stop mit Hilfe des SFC36 und SFC37.

Gruss Daniel


----------



## M-Ott (20 Juni 2011)

Ich denke, jetzt kommt nichts mehr neues.
Vier Tage sollten auch reichen.

Die Abstimmung kann beginnen

Zur Abstimmung:
Am einfachsten wäre, wenn jeder einfach die Nummer des Posts von seiner favorisierten Lösung postet.
Ich denke, morgen mittag als "Wahlschluss" ist ausreichend.
Wer bis dann die meisten Stimmen hat, hat gewonnen.

Mein Favorit ist #7.


----------



## Jochen Kühner (20 Juni 2011)

Bin auch für 7! Aber in die Bausteinsammlung sollte der Baustein von PN/DP (http://sps-forum.de/showpost.php?p=338440&postcount=46)


----------



## dalbi (20 Juni 2011)

Hi,

ich bin auch für 7.

Gruss Daniel


----------



## Paule (20 Juni 2011)

In AWL finde ich auch die Lösung von LargoD #7 / #45 (Diskussions-Thread) am schönsten. Leider fehlen bei #45 noch die Kommentare.

@Jochen
Ich will PN/DP jetzt nichts wegtun, aber er hat doch bei #46 gar nichts zum Post #45 von LargoD geändert, oder sehe ich es nur nicht. 

IN SCL kann ich mich nicht entscheiden, da finde ich die Lösung von Dalbi #17 wie auch von LargoD #27 / #48 (überarbeitet von PN/DP bei Diskussion) klasse.


----------



## Jochen Kühner (20 Juni 2011)

Paule schrieb:


> @Jochen
> Ich will PN/DP jetzt nichts wegtun, aber er hat doch bei #46 gar nichts zum Post #45 von LargoD geändert, oder sehe ich es nur nicht.



Doch, aus

```
L 0
```
wurde

```
L B#16#0
```
was weniger MC7 Code beansprucht!


----------



## PN/DP (21 Juni 2011)

M-Ott schrieb:


> Ich denke, jetzt kommt nichts mehr neues.
> Vier Tage sollten auch reichen.
> 
> Die Abstimmung kann beginnen


Dann hier mal die Zusammenfassung:

```
Anw.   MC7  Anzahl
                  Algorithmus           Zeilen  Byte  Danke  Besonderheiten
----------------------------------------------------------------------------------------------------------------
[URL="http://www.sps-forum.de/showpost.php?p=338023&postcount=3"]1[/URL]  vierlagig      try & catch                6    24    3    führt leider ohne OB121 zum STOP
[URL="http://www.sps-forum.de/showpost.php?p=338051&postcount=5"]2[/URL]* Larry Laffer   Einzelzifferprüfung       29    98    1    sehr leicht verständlich
[URL="http://www.sps-forum.de/showpost.php?p=338075&postcount=6"]3[/URL]* Nordischerjung Einzelzifferprüfung       28    98    1    verarbeitet nur positive BCD-Zahlen
[URL="http://www.sps-forum.de/showpost.php?p=338088&postcount=7"]4[/URL]* LargoD         Parallelbitprüfung 8&4|2  18    64    6    würde auch für BTD nicht mehr Anweisungen benötigen
[URL="http://www.sps-forum.de/showpost.php?p=338155&postcount=8"]5[/URL]  SPSKILLER      Schleife Zifferprüfung    22    80    3    extra 3 Anw.: Fehlerstatus QERR-Ausgang
[URL="http://www.sps-forum.de/showpost.php?p=338210&postcount=10"]6[/URL]  PN/DP          Einzelzifferprüfung       19    60    1    extra 3 Anw.: Fehlerstatus BIE, PLCSIM-Fix

[URL="http://www.sps-forum.de/showpost.php?p=338287&postcount=11"]7[/URL]x PN/DP          KOP 8&4|2 mit dirty LW0   42   140    0    Absolute Zugriffe auf LW0! PLCSIM-Fix
[URL="http://www.sps-forum.de/showpost.php?p=338374&postcount=36"]8[/URL]x PN/DP          KOP 8&4|2 vollsymbolisch  46   226    0    SFC20 für symbolischen Zugriff, PLCSIM-Fix

[URL="http://www.sps-forum.de/showpost.php?p=338504&postcount=17"]9[/URL]  dalbi          SCL Einzelzifferprüfung   13   302    0    BCD-INT-Wandlung in SCL ohne BTI
[URL="http://www.sps-forum.de/showpost.php?p=338538&postcount=27"]10[/URL] LargoD         SCL Parallelbitprüfung     5   166    0    SCL, mit BTI
[URL="http://www.sps-forum.de/showpost.php?p=338552&postcount=28"]11[/URL] dalbi          Direktwandlung ohne Prüfg. 5   124    1    Fehlermaskierung SFC36
[URL="http://www.sps-forum.de/showpost.php?p=338440&postcount=46"]12[/URL] LarD+Th2.1+PN  optimierte Parallelbitpr. 17    50    0    extra Fehlerstatus BIE
[URL="http://www.sps-forum.de/showpost.php?p=338571&postcount=48"]13[/URL] LargoD+PN/DP   optimierte SCL-Parallel.   5    98    0    SCL, mit BTI
```
* Die Lösungen 2, 3 und 4 klassifizieren bestimmte Eingabewerte als Fehler (wegen Vorzeichen-Format), welche BTI nach Siemens-Definition korrekt verarbeiten würde.
x Die Lösungen 7 und 8 sind nur Vergleichs-Demonstrationen, wie aufgeblasen Code wird, der unbedingt in FUP/KOP realisiert werden soll.


Mein Favorit ist ebenfalls die von *LargoD in #7* vorgestellte Parallelbitprüfung (Nr. 4) bzw. die dann hochoptimierte Variante im Diskussionsthread #46 (Nr. 12). Solche über 30 Jahre alten Algorithmen haben schon ihren Charme. Die Entwickler dieser Algorithmen mußten damals vor der eigentlichen Programmierung viel länger theoretisch an der Lösung arbeiten (bevor sie an einen Rechner durften) als heutzutage. Und die Lösungen MUSSTEN auf den damaligen Rechnern effizient sein, oft mußte die Lösung ohne Multiplikation und ohne Division auskommen.

Für eine Bibliotheksversion der Parallelbitprüfung würde ich aber auf jeden Fall noch das Ausblenden der Vorzeichenbits 12-14 einbauen (UW W#16#8FFF), damit der Baustein bezüglich der Vorzeichenbehandlung unter PLCSIM exakt so funktioniert wie auf echten S7-CPU.

Harald


----------



## M-Ott (21 Juni 2011)

Da bisher nur 5 Leute abgestimmt haben, bin ich dafür, noch bis morgen Mittag zu warten.

Ich hoffe, es sind nicht schon alle im Sommerurlaub.


----------



## Der Pfälzer (21 Juni 2011)

PN/DP schrieb:


> Mein Favorit ist ebenfalls die von *LargoD in #7* vorgestellte Parallelbitprüfung (Nr. 4) bzw. die dann hochoptimierte Variante im Diskussionsthread #46 (Nr. 12).
> ...
> Für eine Bibliotheksversion der Parallelbitprüfung würde ich aber auf jeden Fall noch das Ausblenden der Vorzeichenbits 12-14 einbauen (UW W#16#8FFF), damit der Baustein bezüglich der Vorzeichenbehandlung unter PLCSIM exakt so funktioniert wie auf echten S7-CPU.



Ja, seh ich auch so (Bibliotheksversion).
*ACK*
Ich muss zugeben, ich hab am Anfang diese Lösung (Parallelbitprüfung)  kritisch beäugt.
Da sie aber anscheinend funzt (konnte sie noch nicht testen), ist das natürlich eine super Lösung. :s12:
Auch wenn sie nicht jeder "Anfänger" gleich versteht. 

Gruß Roland

P.S. Hoffe, mein DANKE geht noch in die Bewertung ein


----------



## Toki0604 (21 Juni 2011)

Findet die Abstimmung einfach durch Antworten in diesem Thread statt? Wenn Ja dann geht meine Stimme auch an LargoD 7#
Bin ein Freund von Code der Marke kurz/schnell/übersichtlich/AWL.
Auch wenn ich noch daran arbeite den Code nachzuvollziehen...

Gruß
Toki


----------



## rostiger Nagel (21 Juni 2011)

Mann könnte in diesen Thread noch eine abstimmung hinzufügen,
das muss aber der Themenstarter machen.


----------



## M-Ott (21 Juni 2011)

@Helmut
Eigentlich wollte ich keine Abstimmung hinzufügen, da in diesem Thread ja (hoffentlich) noch einige Aufgaben dazukommen und dann jedesmal die Abstimmung geändert werden müsste (ich weiß noch nicht einmal ob das geht).
Ich denke, Abstimmen durch Antworten ist einfacher.


----------



## Paule (21 Juni 2011)

So wie ich das sehe kannst Du da einen Deckel drauf machen.
Die Abstimmung ist doch bis jetzt einstimmig für LargoD.
Selbst wenn da noch irgendeiner aus der Versenkung auftaucht und eine andere Meinung hat, kann er das Ergebnis nicht mehr kippen.


----------



## Jochen Kühner (21 Juni 2011)

*Nächste Aufgabe*

Dann kann LargoD wohl die nächste Aufgabe stellen.
Und wer pflegt den Baustein in die Bausteinbibliothek?


----------



## Onkel Dagobert (21 Juni 2011)

Könnte man nicht eine Rubrik "Programmierwettbewerb Step7" kreieren und dann jede Aufgabe in einem eigenen Thema darstellen? Es würde wesentlich zur Übersicht beitragen. Mit der Abstimmung würde es dann auch einfacher werden.

Gruß, Onkel


----------



## Verpolt (21 Juni 2011)

Ich bin auch so schon begeistert.

Tolle Lösungen :shock:


----------



## M-Ott (22 Juni 2011)

Paule schrieb:


> So wie ich das sehe kannst Du da einen Deckel drauf machen.


Denke ich auch.

*Damit ist LargoD der einstimmige Gewinner der ersten Aufgabe! :sm24: :s12:*

@LargoD
Du darfst dann die nächste Aufgabe stellen.



Onkel Dagobert schrieb:


> Könnte man nicht eine Rubrik "Programmierwettbewerb Step7" kreieren und dann jede Aufgabe in einem eigenen Thema darstellen?


Gute Idee.
Hallo... Admin...


----------



## rostiger Nagel (22 Juni 2011)

Ich möchte darauf hinweisen, das die Fa. Deltalogic bereit ist einen
Preis zu stiften, wir sollten uns mal eine Aufgabe raussuchen, die diesen
Hochwertigen USB-Adapter Verdient.

http://www.sps-forum.de/showpost.php?p=338244&postcount=62


----------



## Onkel Dagobert (22 Juni 2011)

Denkt euch mal eine Aufgabe aus, die eine 64-Bit Realzahl in ein DINT wandelt. Dann setze ich noch einen Kasten Bier oben drauf ;-) .

Gruß, Onkel


----------



## rostiger Nagel (22 Juni 2011)

Onkel Dagobert schrieb:


> Denkt euch mal eine Aufgabe aus, die eine 64-Bit Realzahl in ein DINT wandelt. Dann setze ich noch einen Kasten Bier oben drauf ;-) .
> 
> Gruß, Onkel


 
Onkel das dürfte doch für dich kein Problemm sein, du nimmst deine
Mikrobox, das WinAC ODK und schreibst mal eben ein SFC in "C" und
schon läuft das ding


----------



## M-Ott (22 Juni 2011)

Helmut_von_der_Reparatur schrieb:


> Ich möchte darauf hinweisen, das die Fa. Deltalogic bereit ist einen Preis zu stiften, wir sollten uns mal eine Aufgabe raussuchen, die diesen Hochwertigen USB-Adapter Verdient.


Wir sollten erst noch 2 - 3 Aufgaben machen, bevor wir "ans Eingemachte" gehen, bis dahin hat sich der Wettbewerb auch eingeschliffen.


----------



## LargoD (22 Juni 2011)

M-Ott schrieb:


> *Damit ist LargoD der einstimmige Gewinner der ersten Aufgabe! :sm24: :s12:*
> 
> @LargoD
> Du darfst dann die nächste Aufgabe stellen



Liebe Forumsmitglieder,
Über diese Auszeichnung freue ich mich sehr.
Danke an alle, die zum Gelingen dieser ersten Runde beigetragen haben. Hoffentlich folgen noch viele schöne Runden.
Zur Zeit schreibe ich hier mit einem Smartphone im Freien, in der Ferienwohnung hier an der Ostsee ist kein WLAN und kein Netz, aber die nächste Aufgabe kommt.
Viele Grüße aus Hohwacht
Erich

ps: Soll ich für die neue Aufgabe einen neuen Thread aufmachen?


----------



## MSB (22 Juni 2011)

LargoD schrieb:


> ps: Soll ich für die neue Aufgabe einen neuen Thread aufmachen?



Ich habe mich zwar an der letzten Aufgabe nicht beteiligt, aber der Übersichtlichkeit wäre das sicher dienlich ...


----------

