# Förderband programmieren



## Scrub (28 Juli 2009)

[FONT=&quot]Hallo,

ich benötige Hilfe bei einem Programm für ein Förderband. 
Ich hab mir in SIMI SCE eine Simulation „geschrieben“. Diese sieht wie folgt aus. Es kommen Pakete mit Unterschiedlichen PLZ diese werden gescannt und dann auf unterschiedliche Förderbänder verteilt vor denen jeweils eine Lichtschranke ist. 
Mein Problem ist das die Pakete auch so schnell kommen können, dass mehrere Pakete zwischen  Scanner und den Abweisern sein können. 
Ich hatte vor dieser Aufgabe keine Kenntnisse in SIMATIC, AWL ist mir nicht sehr gut bekannt. Das Programm könnte auch in SCL sein, aber da komme ich mit den SIEMENS Befehlen nicht klar. Bei B&R oder Beckhoff war das anders. Ich scheitere schon daran einen einfachen Timer  (TON) einzufügen. 
Vielleicht kann mir jemand mit einer groben Struktur in AWL oder  in SCL weiterhelfen.

Vielen Dank
[/FONT]


----------



## jackjones (28 Juli 2009)

Ich würde die Pakete Zählen und dann mit nem Schieberegister arbeiten.
Stichwort FIFO (First In, First Out)

Das ganze ist etwas komplexer als ein Zähler 
Du musst den Paketen ja nen Datensatz zuweisen, bzw. ne Kennung wo die rausfliegen sollen.


Hast Du schon was programmiert, dann zeig mal her! Dann helfe ich Dir gerne!


----------



## jackjones (28 Juli 2009)

Du könntest an der Scannstation auch für jedes Paket 1, 2 oder 3 in nem DB ablegen, je nachdem wo das Paket raus soll.
An den Lichtschranken der Pusher zählst Du immer um einen hoch und vergleichst dann die gezählten Werte mit denen in deinem DB auf glechheit, wenn gleich dann raus! 

Wichtig ist auch, das du die Förderstrecke gleich am Anfang initialisierst, das alles auf 0 gesetzt wird! Bedenke, was machst Du wenn sich die Anlage verzählt? Defekftes Paket, Klebebandreste etc... Hast du eine NIO oder Reject Strecke für den Fehlerfall?

Mir würden bestimmt noch mehr Möglichkeiten einfallen. :-D


----------



## Ralle (28 Juli 2009)

Schau dir das hier mal an: http://www.sps-forum.de/showthread.php?t=11632&highlight=auswerfen

Aber wir haben da mit Bits gearbeitet, daß muß dann evtl. geändert werden. Oder man nutzt für jeden Pusher ein eigenes IO-Word. Stehet an der Stelle, des betreffenden Pushers in "seinem" zugeordneten Bit eine 1, dann erfolgt der Auswurf. Man kann, statt Bits zu schieben, auch einen FIFO nutzen. Dazu steht einiges in der FAQ des Forums.


----------



## Scrub (28 Juli 2009)

[FONT=&quot]Das Programm hab ich leider momentan nicht aber es war von dieser Form. Ich hab mir halt dabei gedacht das ich jedesmal eine Variable hochzähle wenn mehrere  Pakete da sind und diese dann bei der Lichtschranke ignoriert werden. Aber das mit dem Schieberegister ist besser, so ne Art Array wo ich dann mit einer  For-schleife alles um eine Position nach vorne schiebe wenn es ausgeworfen wird. So einen Ansatz hatte ich auch mal, sollte man dann für jede PLZ ein Schieberegister verwenden?  Das Problem das ich halt immer noch hab, ist z.B. wenn das erste Paket an den letzten Abweiser soll und das zweite an den ersten Abweiser dann wird ja das zweite Paket vor dem ersten ausgestoßen obwohl es sich im Schieberegister an  der zweiten Position befindet.
ich hoff ich hab mich nicht zu unverständlich ausgedrückt.
vielen Dank für die Hilfe[/FONT]

Die Syntak bei SIMATIC kenn ich nichtvieleicht wird die Idee trotzdem klar.


If PLZ 1 then
  Step1:= 10;
  end_if;

  If PLZ2 then
  Step2:= 10;
  Ignore2:=ignore2+1;

end_if;

  If PLZ3 then
  step3:= 10;
  end_if

case step1 of

10:           if Lichtschranke1 := true and ignore2 = 0 then
                                step1:= 20;
  end _if;
  20:          Abweiser1 := true
                TON(IN:=true, T#200ms)
                If TON.Q  = true then
                                step1:= 30;
                end_if;
  30:        Abweiser1:= false;
                step1:=0;
end_case;


----------



## Ralle (28 Juli 2009)

Mal so vom Prinzip.
Ich würde 3 Schieberegister einsetzen, für jeden Pusher eins. In der einfachsten Version so, wie in dem oben von mir geposteten Beispiel.

Zwei Infos müssen in das Schieberegister, wenn der Scanner fertig ist
a. Paket vorhanden
b. Paket für diesen Pusher bestimmt

In das SR des 1. Pushers müssen alle Pakete eingetragen werden, die durch den Scanner gehen. 
- SR um eins nach rechts schieben
- a. bekommt eine 1, 
- b. bekommt dann eine 1, wenn das Paket auch für den 1. Pusher bestimmt ist.

In das SR des 2. Pushers werden die Pakte eingetragen, die zum 2. und 3. Pusher sollen.
- SR um eins nach rechts schieben, wenn Paket für Pusher 2 oder 3 bestimmt
- a. bekommt eine 1, 
- b. bekommt dann eine 1, wenn das Paket auch für den 2. Pusher bestimmt ist.

In das SR des 3. Pushers werden die Pakte eingetragen, die zum 3. Pusher sollen.
- SR um eins nach rechts schieben, wenn Paket für Pusher 3 bestimmt ist
- a. bekommt eine 1, 
- b. bekommt eine 1

Wenn die LS eines Pushers eine Flanke von einem Paket liefert, muß folgendes ablaufen:

- SR von rechts (!) an durchsuchen, bis bei a. eine 1 gefunden wird.
- Nachsehen, ob bei b. eine 1 vorhanden. 
- wenn b.=1, dann Pusher betätigen und in diesem Element sowohl a. als auch b. mit 0 überschreiben
- wenn b.=0, dann in diesem Element sowohl a. als auch b. mit 0 überschreiben

Das wäre erstmal der Ablauf in Worten.
Eines ist klar, wenn irgend eine LS ein Paket nicht sieht oder 2 Flanken bei einem Paket sieht oder jemand mit der Hand in die LS langt, dann kommt alles durcheinander.
Daher sollte eigentlich jede Pusher einen eigenen Scanner haben, aber das ist natürlich auch eine Kostenfrage.


----------



## Scrub (28 Juli 2009)

ok ich glaube ich hab das Prinzip Verstanden, vielen Dank. ich glaube so hat es auch *jackjones* gemeint. Ich versuch mich mal in das Beispiel einzuarbeiten, da ich ein Schieberegister in AWL nicht kenne. Ich hab mal eine "Lösung" mit einem Schieberegister bzw. Array auf Papier probiert, die kann ich ja, wenn fertig, mal hochstellen vieleicht wäre es so auch möglich.


----------



## Scrub (28 Juli 2009)

Ich hab da ganze mal Grafisch angehängt. könnte es so klappen. Ich hab jetzt ein Schieberegister verwendet. Jede Lichtschranke zählt für sich mit an welcher Stelle sie schauen muss ob das PAket raus muss oder nicht.

 Die Nummern auf den Paketen stehen für den ersten, zweiten oder dritten Pusher. Darüber  ein Array mit den Paket welche vom Scanner erfasst wurden. Das Array wir von rechts nach links gefüllt mit den Informationen für welchen Pusher das Paket ist. Die Zahlen k1 und k2 werden erhöht wenn das Paket nicht für den Pusher ist. Der Pusher weiß dann wo er im Array schauen muss, z.B. k1=2 à Position 3 (immer eins darüber). Wird ein Paket gepushed so werden alle Inhalte eins nach rechts geschoben. Außer in diesem Fall die ersten 2 Pakete.    Allgemein: Wenn ein Paket gepushed wird werden alle k`s die vor dem Pusher sind um eins dekrementiert und alle Array Inhalte eins nach rechts geschoben außer die Stelle die dem aktuellen Pusher und den darauffolgenden entsprechen. 
  Das Array müsste vom Datentyp Wort sein (Kenn mich wiegesagt in AWL damit nicht aus) oder man benutz halt wieder drei  Arrays und setzt da eins und null.
  [FONT=&quot]Könnte das Funktionieren? Hab ich was übersehen. Bin noch am verstehen deiner Lösung. Hab halt mit den Befehlen Probleme (SPBN  KFL1 ist wohl en Sprung, FP Flankenerkennung?, slw?)[/FONT]


----------



## Ralle (28 Juli 2009)

Ich bin da wohl zu dusselig zu, ein paar erklärende Worte zu der PDF würden mir vielleicht auf die Sprünge helfen. 

Hm, du hast jetzt eine Erklärung angefügt, ich werd nicht so recht schlau draus. Aber ok, ist auch wirklich nicht leicht zu erläutern.


----------



## jackjones (28 Juli 2009)

Ich kann da auch beim besten Willen nichts erkennen! 
Bei uns ist es auch so, das jeder Pusher einen Scanner hat. Ist einfach sicherer. 

Eine andere Methode wäre, mit der Ausfuhr am Scanner zu warten, bis das vorherige Paket gepusht wurde. D.H. Das sich immer nur ein Paket hinter der Scannstation befindet. Kommt auf die Länger deiner (Versand?) Bahnen an.

Ansonsten ging mein Ansatz auch in Ralles Richtung! Ich persönlich würde mir alles schön in DB's schreiben.

Einen Tipp hätte ich auch noch, um Dich ganz zu verwirren...
Ein Lieferant bei uns hat auch einen Scanner, danach werden vereinzelt Pakete auf eine NO-Read Strecke gepusht. Hier wird mit einem Inkrementalgeber gearbeitet. Braucht man bei mehr als einer Ausschleus-Stelle aber viel Code ;p


----------



## jackjones (28 Juli 2009)

Scrub schrieb:


> [FONT=&quot]Könnte das Funktionieren? Hab ich was übersehen. Bin noch am verstehen deiner Lösung. Hab halt mit den Befehlen Probleme (SPBN  KFL1 ist wohl en Sprung, FP Flankenerkennung?, slw?)[/FONT]



FP Flanke Positiv, jep!
SPBN Springe wenn VKE=0

Hier kannst Du alle Befehle nachlesen. Nutze ich selbst oft 
AWL Handbuch


----------



## Scrub (30 Juli 2009)

Hallo, ich hab mal angfangen. wenn ich dasProgramm richtig verstanden habe dann wäre das der Teil  wo die Pakete für den ersten Pusher abfragt. oder hab ic da voll den Quatsch gemacht


```
O     "PLZ_74078"                 // Bei mit gibt es nicht was Scanner fertig meldet
      O     "PLZ_74076"
      O     "PLZ_74072"
      FP    M     98.0
      SPBN  KFL1



      L     MW   100                    // Lade ?MW? ???MW = 2Byte???
      SLW   1                           // schiebe eins nach links
      T     MW   100                    // Transferiere in MW 100 ??100.1

      L     MW   102
      SLW   1
      T     MW   102

      SET                               // VKE 1
      S     M    101.0                  //Setze M101.0 =1 warum 101 oben seht doch 100 liegt das am MW

      U     "PLZ_74078"
      S     M    103.0

KFL1: NOP   0                           // Nulloperation was macht das??
```


----------



## jackjones (30 Juli 2009)

Der Scanner muss getriggert sein. Wenn Paket mit Label in Position, dan Lese.
Bei Sick heissen die Triggerlichtschranken meistens Sensor.
Das Signal kann man parallel auf einen DI geben, und spart sich so eine zweite LS.


```
O     "PLZ_74078"                 // Bei mit gibt es nicht was Scanner fertig meldet
      O     "PLZ_74076"
      O     "PLZ_74072"
      FP    M     98.0
      SPBN  KFL1
```

Was passiert wenn 2 Pakete die selbe PLZ haben, hintereinander? Nichts, weil du nicht triggerst! Du würdest dann ja nur 1ne POS Flanke bekommen!
Hier musst du noch Triggern. 
Ist "PLZ_74078" ein Bit oder ne Ganzzahl?

Das MW100 setzt sich aus MB100 und MB101 zusammen, 16 Bits! M100.0, M100.1, M100.2 ..... M101.7

NOP 0 ab da wird das Programm weiter abgearbeitet.


----------



## Scrub (30 Juli 2009)

PLZ ist ein Bit (E 1.1)
Oh, Ich dacht FP wäre dazu um das Problem mit zwei Paketen auszuschließen. 
Aber ich hab ja nichts reales sondern nur ne Simulation in SIMIT SCE die ich anspreche und da bekomme ich immer E1.1 oder E1.2 oder 1.3 = true wenn ein Paket für 74078, 74076, 74072 ist. 
z.B. E1.1 ist nich dauerhaft true ondern nur ca. 1 sec danch false
DI = Digital Inverter?


----------



## Scrub (30 Juli 2009)

So ich hab noch mehr quatsch gemacht 
ist das mit den Registern so gemeint? 
was passiert denn wenn die "oder" Bedingung nicht true ist wird dann trotzdem das Schieberegister um 1 geschoben??
Ich bau das ganze nach dem Code von Ralle auf ich versteh einige Details noch nicht, so z.B. die Unterteilung in NETWORK:
Werden diese gleichzeitig ausgefürt, nacheinader oder muss man da rein springen. ER hat da KFL1 : NOP 0 vor dem nächsten NETWORK gesetzt welcher Sinn steckt dahinter?


```
O     "PLZ_74078"                 // Bei mit gibt es nicht was Scanner fertig meldet
      O     "PLZ_74076"
      O     "PLZ_74072"
      FP    M     98.0
      SPBN  KFL1

// Register Pusher 1
      L     MW   100                    // Lade ?MW? ???MW = 2Byte???
      SLW   1                           // schiebe eins nach links
      T     MW   100                    // Transferiere in MW 100 ??100.1

      L     MW   102
      SLW   1
      T     MW   102

// Register Pusher 2  
      L     MW   104
      SLW   1
      T     MW   104

      L     MW   106
      SLW   1
      T     MW   106

// Register Pusher 3  
      L     MW   108
      SLW   1
      T     MW   108

      L     MW   110
      SLW   1
      T     MW   110


      SET                               // VKE 1
      S     M    101.0                  // Setze M101.0 =1 warum 101 oben seht doch 100 liegt das am MW - Ein Paket war da
      U     "PLZ_74078"                 // Es war die PLZ 74078
      S     M    103.0                  // Wird hier festgelegt das das Paket für den ersten Pusher ist?? Warum 103.0 und nicht 102.0


KFL1: NOP   0                           // Nulloperation was macht das??
```


----------



## Scrub (30 Juli 2009)

Hallo,

die Steuerung für die Simulation scheint zu funktioniern. habs mit drei PAketen Simuliert max. zwei gleichzeitig gescannt. Vielen Dank für die Hilfe. Ich hätte das nie geschaft ohne Eure Hilfe.
Ich stell hier mal Code rein. Hab ihr eine Idee wie ich die Pusher/Sorter wieder abschalten kann? mit ner Zeit Funktion oder so, damit das signal 250 ms anliegt.

Meine Simulation braucht nur einen Impuls um der Pusher anzusteuern und schaltet sich dann selber ab. 

Vielen Dank


```
O     "PLZ_74078"                 // Bei mit gibt es nicht was Scanner fertig meldet
      O     "PLZ_74076"
      O     "PLZ_74072"
      FP    M     98.0
      SPBN  KFL1

// Register Pusher 1
      L     MW   100                    // Lade MW = 2Byte???
      SLW   1                           // schiebe eins nach links Inhalt von z.B.101.0 in 100.7  ?????????
      T     MW   100                    // Transferiere in MW 100 ??100.1

      L     MW   102
      SLW   1
      T     MW   102

      SET                               // VKE 1
      S     M    101.0                  // Ein Paket war da - Setze M101.0 =1 das SR schiebt es dann in 100.7???????? 
      U     "PLZ_74078"                 // Es war die PLZ 74078
      S     M    103.0                  // Wird hier festgelegt das das Paket für den ersten Pusher ist?? 

KFL1: NOP   0                           // Nulloperation was macht das?? A: Nichts :)
//--------------------------------------------------------------------------------------------------------------------------

      O     "PLZ_74076"
      O     "PLZ_74072"
      FP    M     98.1
      SPBN  KFL6

// Register Pusher 2  
      L     MW   104
      SLW   1
      T     MW   104

      L     MW   106
      SLW   1
      T     MW   106

      SET   
      S     M    105.0
      U     "PLZ_74076"
      S     M    107.0

KFL6: NOP   0                           // Nulloperation was macht das?? A: Nichts :)
//---------------------------------------------------------------------------------------------------------------------------

      U     "PLZ_74072"
      FP    M     98.2
      SPBN  KFL7

// Register Pusher 3  
      L     MW   108
      SLW   1
      T     MW   108

      L     MW   110
      SLW   1
      T     MW   110

      SET   
      S     M    109.0
      U     "PLZ_74072"
      S     M    111.0

KFL7: NOP   0                           // Nulloperation was macht das?? A: Nichts :)

NETWORK

  U     "Sorter1"
      FP    M     99.0
      SPBN  KFL2

      U     M    101.7
      SPB   M007
      U     M    101.6
      SPB   M006
      U     M    101.5
      SPB   M005
      U     M    101.4
      SPB   M004
      U     M    101.3
      SPB   M003
      U     M    101.2
      SPB   M002
      U     M    101.1
      SPB   M001
      U     M    101.0
      SPB   M000



M007: SET   
      U     M    103.7
      S     "Motor_sorter1"

      SET   
      R     M    101.7
      R     M    103.7
      SPA   KFL2

M006: SET   
      U     M    103.6
      S     "Motor_sorter1"

      SET   
      R     M    101.6
      R     M    103.6
      SPA   KFL2

M005: SET   
      U     M    103.5
      S     "Motor_sorter1"

      SET   
      R     M    101.5
      R     M    103.5
      SPA   KFL2

M004: SET   
      U     M    103.4
      S     "Motor_sorter1"

      SET   
      R     M    101.4
      R     M    103.4
      SPA   KFL2

M003: SET   
      U     M    103.3
      S     "Motor_sorter1"

      SET   
      R     M    101.3
      R     M    103.3
      SPA   KFL2

M002: SET   
      U     M    103.2
      S     "Motor_sorter1"

      SET   
      R     M    101.2
      R     M    103.2
      SPA   KFL2

M001: SET   
      U     M    103.1
      S     "Motor_sorter1"

      SET   
      R     M    101.1
      R     M    103.1
      SPA   KFL2

M000: SET   
      U     M    103.0
      S     "Motor_sorter1"

      SET   
      R     M    101.0
      R     M    103.0
      SPA   KFL2

KFL2: NOP   0


NETWORK

 U     "Sorter2"
      FP    M     99.1
      SPBN  KFL3

      U     M    105.7
      SPB   M107
      U     M    105.6
      SPB   M106
      U     M    105.5
      SPB   M105
      U     M    105.4
      SPB   M104
      U     M    105.3
      SPB   M103
      U     M    105.2
      SPB   M102
      U     M    105.1
      SPB   M101
      U     M    105.0
      SPB   M100



M107: SET   
      U     M    107.7
      S     "Motor_sorter2"

      SET   
      R     M    105.7
      R     M    107.7
      SPA   KFL2

M106: SET   
      U     M    107.6
      S     "Motor_sorter2"

      SET   
      R     M    105.6
      R     M    107.6
      SPA   KFL2

M105: SET   
      U     M    107.5
      S     "Motor_sorter2"

      SET   
      R     M    105.5
      R     M    107.5
      SPA   KFL2

M104: SET   
      U     M    107.4
      S     "Motor_sorter2"

      SET   
      R     M    105.4
      R     M    107.4
      SPA   KFL2

M103: SET   
      U     M    107.3
      S     "Motor_sorter2"

      SET   
      R     M    105.3
      R     M    107.3
      SPA   KFL2

M102: SET   
      U     M    107.2
      S     "Motor_sorter2"

      SET   
      R     M    105.2
      R     M    107.2
      SPA   KFL2

M101: SET   
      U     M    107.1
      S     "Motor_sorter2"

      SET   
      R     M    105.1
      R     M    107.1
      SPA   KFL2

M100: SET   
      U     M    107.0
      S     "Motor_sorter2"

      SET   
      R     M    105.0
      R     M    107.0
      SPA   KFL2

KFL3: NOP   0


NETWORK

 U     "Sorter3"
      FP    M     99.2
      SPBN  KFL4

      U     M    109.7
      SPB   M207
      U     M    109.6
      SPB   M206
      U     M    109.5
      SPB   M205
      U     M    109.4
      SPB   M204
      U     M    109.3
      SPB   M203
      U     M    109.2
      SPB   M202
      U     M    109.1
      SPB   M201
      U     M    109.0
      SPB   M200



M207: SET   
      U     M    111.7
      S     "Motor_sorter_3"

      SET   
      R     M    109.7
      R     M    111.7
      SPA   KFL2

M206: SET   
      U     M    111.6
      S     "Motor_sorter_3"

      SET   
      R     M    109.6
      R     M    111.6
      SPA   KFL2

M205: SET   
      U     M    111.5
      S     "Motor_sorter_3"

      SET   
      R     M    109.5
      R     M    111.5
      SPA   KFL2

M204: SET   
      U     M    111.4
      S     "Motor_sorter_3"

      SET   
      R     M    109.4
      R     M    111.4
      SPA   KFL2

M203: SET   
      U     M    111.3
      S     "Motor_sorter_3"

      SET   
      R     M    109.3
      R     M    111.3
      SPA   KFL2

M202: SET   
      U     M    111.2
      S     "Motor_sorter_3"

      SET   
      R     M    109.2
      R     M    111.2
      SPA   KFL2

M201: SET   
      U     M    111.1
      S     "Motor_sorter_3"

      SET   
      R     M    109.1
      R     M    111.1
      SPA   KFL2

M200: SET   
      U     M    111.0
      S     "Motor_sorter_3"

      SET   
      R     M    109.0
      R     M    111.0
      SPA   KFL2

KFL4: NOP   0
```


----------



## Ralle (30 Juli 2009)

Ich habs nur mal schnell überflogen, sieht schon ganz gut aus. Du wertest im Prinzip nur ein Byte  aus, daher dürfen nie mehr als 8 Paket unterwegs sein, bevor sie zum letzten Pusher kommen.

Wenn ein Pusher starten setzt du ja einen Merker. mit dem läßt du den Pusher laufen. Gleichzeitig eine SE-Zeit mit S5t#250ms mit dem Merker versorgen. Wenn diese Zeit dann auf 1 geht, den Merker zurücksetzen.

Noch was zum Schieben im Wortd Es ist leider so, daß, wenn man in einem Wort SRW 1 durchführt, die Bits wie folgt geschoben werden:

M 101.0 --> M101.1 --> M101.2 .... --> M101.7 --> M100.0 --> M100.1 ... --> M100.7

Das liegt an der Reihenfolge der Bytes in dem Word. Daher sieht das erstmal komisch aus, wenn man M101.0 setzt und dann das Word schiebt. Kannst du ja mal in der Simulation ansehen.

PS. Da du im Prinzip nur mit einem Byte arbeitest fällt das kaum noch auf.


----------



## Sven_HH (30 Juli 2009)

Zum Bit schieben verwenden wir meist den FC92: "Bit in Bitschieberegister schieben" aus der TI-S7 Converting Blocks Library.

Dort kannst Du die Anzahl der zu schiebenden Bits vorgeben und es wird "Berg auf" geschoben.

gruß
Sven


----------



## Scrub (31 Juli 2009)

Hallo,
ich weiß nich genau wie ich den SE ansprechen soll. kann da jemand vieleicht an richtiger Stelle einfügen. SE soll mit dem MotorSorter getartet werden. Wo kann ich ihn am besten ausschalten?
gruß und danke

```
U     T      3
      =     M     97.0
      R     "Motor_sorter1"
      R     T      3

      U     "Sorter1"
      FP    M     99.0
      SPBN  KFL2

      U     M    101.7
      SPB   M007
      U     M    101.6
      SPB   M006
      U     M    101.5
      SPB   M005
      U     M    101.4
      SPB   M004
      U     M    101.3
      SPB   M003
      U     M    101.2
      SPB   M002
      U     M    101.1
      SPB   M001
      U     M    101.0
      SPB   M000



M007: SET   
      U     M    103.7
      S     "Motor_sorter1"
      L     S5T#500MS
      SE    T      1


      SET   
      R     M    101.7
      R     M    103.7
      SPA   KFL2

M006: SET   
      U     M    103.6
      S     "Motor_sorter1"
      L     S5T#500MS
      SE    T      1


      SET   
      R     M    101.6
      R     M    103.6
      SPA   KFL2

M005: SET   
      U     M    103.5
      S     "Motor_sorter1"

      SET   
      R     M    101.5
      R     M    103.5
      SPA   KFL2

M004: SET   
      U     M    103.4
      S     "Motor_sorter1"

      SET   
      R     M    101.4
      R     M    103.4
      SPA   KFL2

M003: SET   
      U     M    103.3
      S     "Motor_sorter1"

      SET   
      R     M    101.3
      R     M    103.3
      SPA   KFL2

M002: SET   
      U     M    103.2
      S     "Motor_sorter1"

      SET   
      R     M    101.2
      R     M    103.2
      SPA   KFL2

M001: SET   
      U     M    103.1
      S     "Motor_sorter1"
      L     S5T#500MS
      SE    T      1


      SET   
      R     M    101.1
      R     M    103.1
      SPA   KFL2

M000: SET   
      U     M    103.0
      S     "Motor_sorter1"
      L     S5T#500MS
      SE    T      1


      SET   
      R     M    101.0
      R     M    103.0
      SPA   KFL2

KFL2: NOP   0
```


----------



## Ralle (31 Juli 2009)

Setz das ganz ans Ende unter das Programm, so daß die Zeit immer vom Programm abgearbeitet wird, nicht in abhängig von Sprüngen. Die Zeit nur einmal nutzen. Wenn der Merker gesetzt ist läuft die Zeit ab. Dort kann dann auch das Rücksetzen mit hin.


```
U "Motor_sorter1"
      L     S5T#500MS
      SE    T      1
```


----------

