# Lauflicht AWL



## Schüler10 (4 Juli 2011)

Hallo 

ich muss drei lauflichter in AWL programieren und bekomme es nicht hin.
Die lauflichter sollen wie in der angehängten grafik funktionieren, für jedes lauflicht muss ich ein einzelnes program schreiben. 
ich würde mcih sehr freuen wenn mir jemand helfen könnte.

Was ich noch aus dem letztem unterricht habe ist dies:

    UN                  Takt
    BEB
    L                     B_counter
    L                     0
    <>I
    SPB                 Go1
    L                     0
    T                     B_Muster
    SPA                Go3

  Go1:      L                     B_counter
              L                     1
              <>I
              SPB                 Go2
              L                     1
              T                     B_Muster
              SPA                Go3

  Go2:      L                     B_counter
              L                     2
              <I                    
              SPB                 Go3
              L                     B_Muster
              SLW1
              OW
              T                     B_Muster

  Go3:      L                     B_counter
              INC1
              T                     B_counter
              L                     B_counter
              L                     16
              <I
              BEB
              L                     0
              T                     B_counter

Leider schaffe ich es nicht den B_Counter oder den B_Muster auszugeben.


----------



## bike (4 Juli 2011)

Schüler10 schrieb:


> Was ich noch aus dem letztem unterricht habe ist dies:
> 
> UN                  Takt
> BEB
> ...



Was macht dein Counter?
Der zählt, denke ich mal.
Deine Vergleicher sind nicht so ganz glücklich gewählt und wenn du nicht immer BEB machen würdest, sondern zu einer Ausgabe des Zählerstandes springen würdest, wärst du am Ziel.


bike

P.S: so viele Konjunktive habe ich selten geschrieben


----------



## Schüler10 (4 Juli 2011)

der zähler soll immer ein licht ein und danach das nächste einschalten, wie springe ich zu einer ausgabe des zählers? und sollte ich die am ende der go1-3 machen?


----------



## bike (4 Juli 2011)

Schüler10 schrieb:


> der zähler soll immer ein licht ein und danach das nächste einschalten, wie springe ich zu einer ausgabe des zählers? und sollte ich die am ende der go1-3 machen?


Also dein go1-3 passt nicht so echt.

Geht es um die erste Aufgabe?
Da sollst zuerst prüfen ob der Zählerstand größer gleich 17 ist.
Wenn nicht den Zähler erhöhen.

```
Un Taktimpuls      // Kein Impuls 
spb end               // dann zum Ende
L Zaehler             // Sonst lade Zaehler 
L 17                    // Grenze
>=I                     // vergleichen
SPB loes           // wenn der Wert ereicht Zaehler loeschen
L Zaehler 
L 1
+I
T Zaehler
L Ausgabe        // Ausgabe ist das Ausgangswort
shl 1                 // den Ausgang nach links schieben
T Ausgabe        // und speichern
spb ende
loes: Nop 0
L 0
T Zaehler
t Ausgabe
SPA end

ende: nop 0
```
Als Anfang für dein Programm, ist nicht ganz fertig und nicht getestet.

Viel Erfolg


bike


----------



## NikolausL (5 Juli 2011)

Guten Morgen,

kleine Korrektur des Codes:


```
L 0 
T Zaehler 
L 1
t Ausgabe 
SPA end
```

Viele Grüße
Klaus


----------



## Sinix (5 Juli 2011)

bike schrieb:


> A
> Da sollst zuerst prüfen ob der Zählerstand größer gleich 17 ist.
> 
> 
> ...



Ich würde erst erhöhen, dann prüfen, das spart etwas Code, oder?

```
UN Taktimpuls
SPB OUT

L Zähler
SLW 1
T Zähler

L 8
>I
SPBN OUT

L 0
T Zähler

OUT: L Zähler
T Ausgangsbyte
```


----------



## NikolausL (5 Juli 2011)

Hallo,

Damit das überhaupt funktioniert, muß doch vor dem ersten Start die Variable Zähler erstmal mit 1 vorbelegt werden, sonst werden ja nur Nullen durch die Gegend geschoben. Das gleiche gilt, wenn das Programm durchgelaufen ist.
Damit 16 Bit durchgeschoben werden, muß der Zähler auf -32768 abgefragt werden ( = 2#1000 0000 0000 0000). Also so:


```
UN Taktimpuls 
SPB OUT 

L Zähler
L 0
==I
spb INI

L Zähler 
SLW 1 
T Zähler  

L -32768 
<>I 
SPB OUT  

INI: L 1 
T Zähler  

OUT: L Zähler 
T Ausgangsbyte
```

Viele Grüße 
Klaus


----------



## eNDe (5 Juli 2011)

Hallo Schüler10,
endlich mal einer, der auf der Grundlage eines Struktogrammes ein Programm entwickelt. 
Die Umsetzung von Struktogramm nach AWL hast du aber noch nicht richtig verstanden.
Ein Struktogramm wird immer von oben nach unten gelesen und deshalb auch so programmiert. 
Für das erste Beispiel gebe ich dir mal die richtige AWL. 

```
[SIZE=2]      L    #Muster[/SIZE]
[SIZE=2]      T    #Ausgaenge[/SIZE]
[SIZE=2] [/SIZE]
[SIZE=2]     U    #Taktimpuls[/SIZE]
[SIZE=2]      SPB  vorh[/SIZE]
[SIZE=2]      BEB[/SIZE]
[SIZE=2][/SIZE] 
[SIZE=2]vorh  :L    #ZW[/SIZE]
[SIZE=2]      L    17[/SIZE]
[SIZE=2]      ==I[/SIZE]
[SIZE=2]      SPBN nein[/SIZE]
[SIZE=2][/SIZE] 
[SIZE=2]      L    1[/SIZE]
[SIZE=2]      T    #ZW[/SIZE]
[SIZE=2]      T    #Muster[/SIZE]
[SIZE=2]      BEB[/SIZE]
[SIZE=2][/SIZE] 
[SIZE=2]nein  :L    #ZW[/SIZE]
[SIZE=2]      INC            1[/SIZE]
[SIZE=2]      T    #ZW[/SIZE]
[SIZE=2][/SIZE] 
[SIZE=2]      L    #Muster[/SIZE]
[SIZE=2]      SLW            1[/SIZE]
[SIZE=2]      T    #Muster[/SIZE]
```
Du solltest versuchen, die AWL-Zeilen den einzelnen Struktogrammelementen genau zuzuordnen.
Wenn du das verstanden hast, werden dir die anderen beiden Programme mit Leichtigkeit gelingen.
Viel Erfolg!
eNDe


----------



## Schüler10 (5 Juli 2011)

eNDe schrieb:


> Hallo Schüler10,
> endlich mal einer, der auf der Grundlage eines Struktogrammes ein Programm entwickelt.
> Die Umsetzung von Struktogramm nach AWL hast du aber noch nicht richtig verstanden.
> Ein Struktogramm wird immer von oben nach unten gelesen und deshalb auch so programmiert.
> ...



Danke ich habe das einmal so abgetippt habe jetzt aber das Problem dass Ausgaenge, Muster und ZW als Byte deklariert werden muss, ich denke du Benutzt die Variable Muster als ausgang für die Lampen die angeschlossen werden sollen. wie kann ich nun die Lampen ansteuern? muss ich dazu Byte wieder in BOOL umrechnen? oder das mittels Vergleichern lösen?


----------



## Sinix (5 Juli 2011)

Was ist so schlimm Variablen als Byte zu deklarieren?

Ausgaenge als Byte und nur damit werden die Lampen angesteuert.
Muster und ZW als Word, da du ja lt. Aufgabenstellung Schiebe Befehle benutzten sollst, in dem Fall SLW.


----------



## Schüler10 (5 Juli 2011)

Danke das klappt nun soweit mit dem Programm von eNDe allerdings finde ich es ein bischen schwer zu simulieren da die geschwindigkeit sehr hoch ist und ich dadurch deen eindruck habe dass am schluss etwas nicht stimmt, wenn ich manuell drauf klicke um nach jedem durchgang zu stoppen bekomme ich den eindruck dass die reihenfolge irgendwie nciht in ordnung ist.

gibt es eine möglichkeit die geschwindigkeit der simulation runter zu setzen um dies zu checken?


----------



## Sinix (5 Juli 2011)

Klar geht das langsamer, wie bildest du den Taktimpuls?


----------



## Schüler10 (5 Juli 2011)

den habe ich im moment direkt durch einen eingang den ich dauerhaft gesetzt habe gebildet! soll ich das durch eine einschalt bzw ausschalt verzögerung ersetzen?


----------



## Schüler10 (5 Juli 2011)

Habe es jetzt mit einem S_Everz gelöst mit dem kann ich nun schön die zeiten einschalten


----------



## Sinix (5 Juli 2011)

nöö,  es sollte reichen

```
U Ex.x
FP Mx.x
= Taktimpuls
```

FP ist eine positive Flankenauswertung, also wird immer beim Einschalten des Eingang dein Lauflicht weitergeschaltet.


----------



## Schüler10 (5 Juli 2011)

OK die erste aufgabe habe ich soweit hinbekommen und verstanden, allerdings habe ich bei der zweiten das problem dass ich nicht weiß wie ich eine 1 anstelle einer 0 nachschiebe. mein Programm sieht momentan so aus

       L     #Muster
        T     #Ausgaenge

        U     #Taktimpuls
        SPB   vorh
        BEB   
  vorh: L     #ZW
        L     33
        >=I   
        SPBN  nein

        L     1
        T     #ZW
        T     #Muster
        BEB   



        L     #ZW
        L     0
        >I    
        SPB   ja
        NOP   0

  ja:   L     #ZW
        L     17
        <I    
        SPB   ja2
        NOP   0

  ja2:  SLW   1



        L     #ZW
        L     16
        >I    
        SPB   ja3
        NOP   0

  ja3:  L     #ZW
        L     34
        <I    
        SLW   1


  nein: L     #ZW
        INC   1
        T     #ZW

        L     #Muster
        SLW   1
        T     #Muster


----------



## Sinix (5 Juli 2011)

Der Prüfer will hier sehen, dass du eine Fallunterscheidung machst.
Da Aufgabe 1) das Struktogramm ist, meine ich das dies schon Falsch gelöst ist, denn lt. der Vorgabe FB102 würde ich in Worten es so beschreiben:

 Eine "1" nachschieben bis alle Bits = "1", Startbedingung 1
Eine "0" nachschieben bis alle Bits = "0", Startbedingung 31

Du benötigst dazu eine Hilfsvariable (Hilfsmerker) zur Fallunterscheidung.


----------



## bike (5 Juli 2011)

Jetzt wurde dir eine fertige Funktion geliefert.
Verstanden hast du scheinbar nicht.

Warum wieder BEB?
Bei BEB ist das Debuggen schwerer als wenn du zu einem ENDE Labe springst.

Warum versuchst du nicht zuerst zu verstehen, bevor du dir das nächste Programm abholst?

So ist geht der Lernerfolg gegen Null.



bike


----------



## Schüler10 (5 Juli 2011)

Ich danke euch ich habe es nun endlich hin bekommen. hat mich zwar einen ganzen mittag gekostet aber dank euren tipps war es nun doch lösbar für mich


----------



## eNDe (5 Juli 2011)

*Lauflicht in AWL*

Hallo Schüler10
grundsätzlich ist ein Struktogramm ohne Äderung umzusetzen. Das 2. Struktogramm beschreibt das Lauflicht fehlerfrei. Wenn du es also genau so programmierst wie es dasteht, läuft die Anwendung auf Anhieb fehlerfrei. 
Die ersten beiden Befehle sind deshalb OK.
Der folgende nicht, denn du fragst den Takt auf true ab und nicht auf False (richtig wäre UN #Taktimpuls). Danch musst du den richtigen Sprungbefehl verwenden (Antwort-Vorgabe lt. Struktogramm beachten)
Zwei Dinge hast du noch nicht richtig verstanden:
1. Die NOP 0 sind falsch. Hier müssten Sprungbefehle verwendet werden nach folgendem Prinzip (Gilt bei ZW>0 und ZW<17): 
Erste Abfrage nach >0. Wenn diese bereits false liefert, kannst du sofort in den Folgebefehl springen ohne nach <17 zu fragen. Liefert diese Abfrage aber true, muss auch noch nach <17 gefragt werden. Im Falle von false ebenfalls in den Folgebefehl springen. Nur im Falle von true den ja-Befehl überlaufen.
2. Hier zunächst kurz das Prinzip des Struktogrammes. Im Struktogramm wird die Struktur der Aktionen dargestellt. Hinter einer solchen Aktion kann sich aber ein umfangreicheres Programm verbergen. Erst wenn diese Aktion durchlaufen ist, ist sie auch abgeschlossen.
Die Aktion "Schiebe Muster um 1 nach links und verbinde es mit dem alten Muster" ist eine solche "komplexere" Aktion. Hierfür könnte man folgendes Unter-Struktogramm realisieren (in Worten)
- hole altes Muster ( L #Muster)
- Schiebe um 1 Position nach links (SLW 1)
- hole erneut altes Muster (L #Muster)
- verodere beide Worte (OW)
- speichere das neue Muster als "altes" Muster wieder ab (T #Muster)
Vielleicht hilft dir das schon!
Noch ein Tipp: Schreibe oben links in die Aktionen des Struktogramms, welche ein Sprungziel darstellen, vorher geeignete Markennamen rein. Das hilft bei der Umsetzung dann ungemein.
Viel Erfolg
eNDe


----------



## Sinix (6 Juli 2011)

Hallo eNDe, bist du dir ganz sicher?



eNDe schrieb:


> grundsätzlich ist ein Struktogramm ohne Äderung umzusetzen. Das 2. Struktogramm beschreibt das Lauflicht fehlerfrei. Wenn du es also genau so programmierst wie es dasteht, läuft die Anwendung auf Anhieb fehlerfrei.
> ...
> eNDe


----------



## eNDe (6 Juli 2011)

*Lauflicht mit AWL*

Hallo Mäuseklavier,
habe das 2. Struktogramm nicht getestet, halte es aber für richtig!
Das Verbinden von Muster alt und Muster neu kann nur über verodern erfolgen. Dann ergibt sich "automatisch" das geforderte Bitmuster. Stelle doch deinen Code mal hier ein (oder schick mir eine PN), dann schaue ich mir das mal an. Falls Schüler10 das hier liest, biete ich ihm an, auch seinen Code mal zu testen. Eine fertige Umsetzung des Struktogramms Nr. 2 (oder 3) gibt es öffentlich von mir hier nicht!
Viel Erfolg!
eNDe


----------



## eNDe (6 Juli 2011)

*Lauflicht mit AWL*

Hallo Mäuseklavier und Schüler10,
habe das 2. Struktogramm 1 zu 1 umgesetzt, es klappt 100%ig.
38 AWL-Zeilen.
eNDe


----------



## Sinix (6 Juli 2011)

@eNDe 

ok, war ein bischen konfus, ZW und Muster sind natürlich 2 verschiedene Variablen, dann passt es etwa. Kleiner Mangel ist aber, das die Variable Muster am Anfang 0 ist und somit bis zum ersten Erreichen von ZW>=33 nur Nuller geschoben werden.


----------



## Schüler10 (6 Juli 2011)

Also ich habe Das zweite Sturktugramm abgeändert so dass ich trozdem die funktion erfüllt habe mein code sieht nun so aus: 



> U     #Taktimpuls
> SPB   vorh
> BEB
> vorh: L     #ZW
> ...


----------



## eNDe (6 Juli 2011)

*Lauflicht in AWL*

Hallo Schüler10,
dein Programm funktioniert (sofern ich das übersehe). Trotzdem würde ich dir dafür keine gute Note geben, denn du hast die Aufgabe nicht erfüllt.
Zunächst würde ich dir als Lehrer die Aufgabe stellen, dein Programm als Struktogramm darzustellen.
Zweitens würde ich deine Meinung hören wollen zu folgender Situation:
Für eine Vielzahl teilweise sehr komplexer Steuerungsabläufe gibt es fertige Struktogramme. Diese sind im Bedarfsfalle für eine konkrete Steuerung umzusetzen (denke daran, es gibt nicht nur STEP7). 
Manchmal kann man gar nicht nachvollziehen, wieso das Struktogramm eine bestimmte Aufgabe löst. Das ist besonders bei rekursiven Programmen häufig der Fall. (siehe Beispiele).
Es wird also nichts, wenn man das Struktogramm nicht umsetzen kann und dafür der Einfachheit halber mal schnell ein "Ersatzprogramm" entwickelt. 
Ich denke mal, du lernst gerade den richtigen Weg und solltest dich entsprechend bemühen. Also: Aufgabe 2 nochmal und zwar exakt nach Vorgabe.
Viel Erfolg!
eNDe


----------



## eNDe (6 Juli 2011)

*Lauflicht in AWL*

Zweiter Versuch für die Grafik


----------

