Step 7 Lauflicht

Spucas Leicher · 18 Januar 2017

Hallo Leute

Folgende Aufgabe: Solange der Taster gedrückt ist, sollen 5 Lampen nacheinander aufleuchten. Immer wieder von vorne bis der Taster losgelassen wird.
Mein Code sieht bis jetzt wie folgt aus:

Code:

      U     Taster 1
      L     S5T#0MS
      SE    T    111
      U     T    112
      R     T    111
      U     T    111
      =     Lampe 1



      U     Taster 1
      L     S5T#2S
      SE    T    112
      U     T    113
      R     T    112
      U     T    112
      =     Lampe 2


      U   Taster 1
      L     S5T#3S
      SE    T    113
      U     T    114
      R     T    113
      U     T    113
      =    Lampe 3


      U   Taster 1
      L     S5T#4S
      SE    T    114
      U     T    115
      R     T    114
      U     T    114
      =    Lampe 4


      U    Taster 1
      L     S5T#5S
      SE    T    115
      U     T    116
      R     T    115
      U     T    115
      =     Lampe 5


      U     Taster 1
      L     S5T#6S
      SE    T    116

Das funktioniert auch wunderbar, aber sobald es einmal durchlaufen ist, soll es wieder von vorne anfangen.
Gibt es eine Funktion, die das Ganze wieder von vorne starten lässt?

P.S.: Gibt es einen Befehl der eine Lampe blinken lässt?(nächste Aufgabe)

Spawn · 18 Januar 2017

Moin,

such doch hier im Forum mal nach "Schrittkette", das könnte vielleicht helfen.

MfG Spawn

Spucas Leicher · 18 Januar 2017

Taktmerker ist das Zauberwort. Glaube ich zumindest xD

online · 18 Januar 2017

Such mal nach Loop / Schiebe-Befehle oder direkt nach Lauflicht, das gab es schon einige mal.

Automatio · 18 Januar 2017

Spucas Leicher schrieb:
Taktmerker ist das Zauberwort. Glaube ich zumindest xD

Machst du jetzt für jede deiner Aufgaben ein Thread auf, den du dir nach 20 Minuten überlegen ersparen kannst?...

Spucas Leicher · 18 Januar 2017

So sei es

PN/DP · 18 Januar 2017

Spucas Leicher schrieb:
Folgende Aufgabe: Solange der Taster gedrückt ist, sollen 5 Lampen nacheinander aufleuchten. Immer wieder von vorne bis der Taster losgelassen wird.

Man könnte für die Aufgabe einen Zähler und einen Timer (für den Weiterschalttakt) und 6 Vergleicher nehmen. Mit dem Zähler 1 bis 5 zählen und bei Zählerstand > 5 den Zähler auf 1 zurücksetzen. Der Taster negiert am Rücksetzeingang hält den Zähler auf 0.

Spucas Leicher schrieb:
P.S.: Gibt es einen Befehl der eine Lampe blinken lässt?(nächste Aufgabe)

Lampe_Einschaltbit UND Blinktakt

Für Weiterschalttakt und Blinktakt kann man statt Timern auch die System-Taktmerker nehmen, wenn die CPU passende Taktmerker hat.

Harald

Spucas Leicher · 18 Januar 2017

Das mit den Taktmerkern funktioniert nicht so ganz.

Kann ich mit einem LOOP das ganze wiederholen?
Falls ja, wie benutze ich diesen Befehl?
Gibt es noch eine andere Möglichkeit?

hucki · 18 Januar 2017

Spucas Leicher schrieb:
Das mit den Taktmerkern funktioniert nicht so ganz.

Schau mal in Haralds Signatur!

Den Taktmerker darfst Du natürlich nicht selbst als Schaltkriterium nutzen, da dieser mehr als nur einen Zyklus hintereinander auf HIGH ist.
Was Dich am Taktmerker interessiert, ist sein Zustandswechsel. Und den stellt man wie fest?

PS: Übrigens ist die Detektierung des Zustandswechsel bei den Zählern schon integriert.

PN/DP · 18 Januar 2017

Taktmerker müssen in HW Konfig eingestellt werden und dann die HW Konfig in die CPU geladen werden

Mit LOOP kannst Du nicht wiederholen. Mit LOOP kann man nur eine Schleife innerhalb eines Programmstücks für gaaanz kurze Zeit wiederholen - dauert das länger als die eingestellte maximale OB1-Zykluszeit (z.B. 150ms) dann ergibt das den Fehler "Zykluszeitüberschreitung" mit üblicherweise STOP des Anwenderprogramms. Zuweisungen an das Prozessabbild der Ausgänge innerhalb einer LOOP-Schleife haben keinen Effekt auf die Baugruppen-Ausgänge (Peripherie) - die Digital-Ausgänge werden erst nach dem Ende des OB1 zugewiesen/geschaltet.

Wiederholen: Schrittkette schreiben oder einen Ablauf, der sich am Ende selber neu startet, z.B.
- UN T3 ---> SE T1
- U T1 ---> SE T2
- U T2 ---> SE T3

Harald

Spucas Leicher · 18 Januar 2017

Also ich habe es jetzt einfach so gemacht, dass ich den Code quasi 4 mal hintereinander laufen lasse:

Code:

 U     "U07SpID".SchulA7T12.Sig
      L     S5T#0MS
      SE    T    111
      U     T    112
      R     T    111
      U     T    111
      =     "U07SeqD".Seq.User.Bit10

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#1S
      SE    T    112
      U     T    113
      R     T    112
      U     T    112
      =     "U07SeqD".Seq.User.Bit11


      U     "U07SpID".SchulA7T12.Sig
      L     S5T#2S
      SE    T    113
      U     T    114
      R     T    113
      U     T    113
      =     "U07SeqD".Seq.User.Bit12

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#3S
      SE    T    114
      U     T    115
      R     T    114
      U     T    114
      =     "U07SeqD".Seq.User.Bit13


      U     "U07SpID".SchulA7T12.Sig
      L     S5T#4S
      SE    T    115
      U     T    116
      R     T    115
      U     T    115
      =     "U07SeqD".Seq.User.Bit14


      U     "U07SpID".SchulA7T12.Sig
      L     S5T#5S
      SE    T    116
      U     T    117
      R     T    116
      U     T    116
      =     "U07SeqD".Seq.User.Bit15

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#6S
      SE    T    117
      U     T    118
      R     T    117
      U     T    117
      =     "U07SeqD".Seq.User.Bit16

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#7S
      SE    T    118
      U     T    119
      R     T    118
      U     T    118
      =     "U07SeqD".Seq.User.Bit17

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#8S
      SE    T    119
      U     T    120
      R     T    119
      U     T    119
      =     "U07SeqD".Seq.User.Bit18

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#9S
      SE    T    120
      U     T    121
      R     T    120
      U     T    120
      =     "U07SeqD".Seq.User.Bit19

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#10S
      SE    T    121
      U     T    122
      R     T    121
      U     T    121
      =     "U07SeqD".Seq.User.Bit20

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#11S
      SE    T    122
      U     T    123
      R     T    122
      U     T    122
      =     "U07SeqD".Seq.User.Bit21

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#12S
      SE    T    123
      U     T    124
      R     T    123
      U     T    123
      =     "U07SeqD".Seq.User.Bit22

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#13S
      SE    T    124
      U     T    125
      R     T    124
      U     T    124
      =     "U07SeqD".Seq.User.Bit23

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#14S
      SE    T    125
      U     T    126
      R     T    125
      U     T    125
      =     "U07SeqD".Seq.User.Bit24

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#15S
      SE    T    126
      U     T    127
      R     T    126
      U     T    126
      =     "U07SeqD".Seq.User.Bit25

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#16S
      SE    T    127
      U     T    128
      R     T    127
      U     T    127
      =     "U07SeqD".Seq.User.Bit26

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#17S
      SE    T    128
      U     T    129
      R     T    128
      U     T    128
      =     "U07SeqD".Seq.User.Bit27

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#18S
      SE    T    129
      U     T    130
      R     T    129
      U     T    129
      =     "U07SeqD".Seq.User.Bit28

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#19S
      SE    T    130
      U     T    131
      R     T    130
      U     T    130
      =     "U07SeqD".Seq.User.Bit29

      U     "U07SpID".SchulA7T12.Sig
      L     S5T#20S
      SE    T    131
      U     T    132
      R     T    131
      =     "U07SeqD".Seq.User.Bit30







      U     "U07SeqD".Seq.User.Bit10
      O     "U07SeqD".Seq.User.Bit15
      O     "U07SeqD".Seq.User.Bit20
      O     "U07SeqD".Seq.User.Bit25
      =     "U07ActD".SchulA7L11.ACo

      U     "U07SeqD".Seq.User.Bit11
      O     "U07SeqD".Seq.User.Bit16
      O     "U07SeqD".Seq.User.Bit21
      O     "U07SeqD".Seq.User.Bit26
      =     "U07ActD".SchulA7L12.ACo

      U     "U07SeqD".Seq.User.Bit12
      O     "U07SeqD".Seq.User.Bit17
      O     "U07SeqD".Seq.User.Bit22
      O     "U07SeqD".Seq.User.Bit27
      =     "U07ActD".SchulA7L13.ACo

      U     "U07SeqD".Seq.User.Bit13
      O     "U07SeqD".Seq.User.Bit18
      O     "U07SeqD".Seq.User.Bit23
      O     "U07SeqD".Seq.User.Bit28
      =     "U07ActD".SchulA7L14.ACo


      U     "U07SeqD".Seq.User.Bit14
      O     "U07SeqD".Seq.User.Bit19
      O     "U07SeqD".Seq.User.Bit24
      O     "U07SeqD".Seq.User.Bit29
      =     "U07ActD".SchulA7L15.ACo

Da ich nicht verstehe, wie es anders gehen soll.
Vielleicht kann mir ja jemand eine Anmerkung an die entsprechenden Zeilen machen, wo ich z.B die Bits zurücksetzen soll.
Vielen Dank schonmal

P.S.: Da der Code so lang ist, habe ich ihn in meiner Version gelassen, sorry

hucki · 18 Januar 2017

Variante mit S5-Zähler/-Timer:

Code:

// Taktgeber:
      U     #Start
      UN    #Takt
      L     S5T#1S
      SA    "TimerTakt"

      U     "TimerTakt"
      =     #Takt

// Zähler:
      U     #Takt
      ZV    "Lampenwahl"

      L     6
      L     "Lampenwahl"
      ==I   
      ON    #Start
      R     "Lampenwahl"
      R     "TimerTakt"

// Lampen:
      L     1
      L     "Lampenwahl"
      ==I   
      =     #Lampe1

      L     2
      L     "Lampenwahl"
      ==I   
      =     #Lampe2

      L     3
      L     "Lampenwahl"
      ==I   
      =     #Lampe3

      L     4
      L     "Lampenwahl"
      ==I   
      =     #Lampe4

      L     5
      L     "Lampenwahl"
      ==I   
      =     #Lampe5

PN/DP · 19 Januar 2017

PN/DP schrieb:
Wiederholen: Schrittkette schreiben oder einen Ablauf, der sich am Ende selber neu startet, z.B.
- UN T3 ---> SE T1
- U T1 ---> SE T2
- U T2 ---> SE T3

Für 5 Lampen sieht das so aus:

Code:

      U     #Start
      UN    T5
      =     #Lampe1
      U     #Lampe1
      L     S5T#1S
      SE    T1
      U     T1
      =     #Lampe2

      U     T1
      L     S5T#1S
      SE    T2
      U     T2
      =     #Lampe3

      U     T2
      L     S5T#1S
      SE    T3
      U     T3
      =     #Lampe4

      U     T3
      L     S5T#1S
      SE    T4
      U     T4
      =     #Lampe5

      U     T4
      L     S5T#1S
      SE    T5

PN/DP schrieb:
Man könnte für die Aufgabe einen Zähler und einen Timer (für den Weiterschalttakt) und 6 Vergleicher nehmen. Mit dem Zähler 1 bis 5 zählen und bei Zählerstand > 5 den Zähler auf 1 zurücksetzen. Der Taster negiert am Rücksetzeingang hält den Zähler auf 0.

Code:

      U     #Start
      U     #Takt
      ZV    Z1

      L     Z1
      L     5
      >I
      L     C#0
      S     Z1

      UN    #Start
      R     Z1

      L     Z1
      L     1
      >=I
      =     #Lampe1

      L     Z1
      L     2
      >=I
      =     #Lampe2
...

Soll die Zähler-Variante in FUP/KOP darstellbar sein, dann sind noch zusätzliche Anweisungen nötig:

Code:

      U     #Start
      U     #Takt
      ZV    Z1
      BLD   101
      U(
      L     Z1
      T     #Z1Int
      SET
      SAVE
      CLR
      U     BIE
      )
      U(
      L     #Z1Int
      L     5
      >I
      )
      L     C#0
      S     Z1
      UN    #Start
      R     Z1
      NOP   0
      NOP   0
      NOP   0

Harald

Spucas Leicher · 19 Januar 2017

Vielen Dank Harald!
Da meine Lampen nur kurz aufleuchten sollen, habe ich sie jeweils einfach im nächsten Schritt zurück gesetzt.

Code:

 U     Taster 1
      UN    T    115
      =     Lampe 1

      U    Lampe 1
      L     S5T#1S
      SE    T    111
      U     T    111
      R     Lampe 1
      =     Lampe 2


      U     T    111
      L     S5T#1S
      SE    T    112
      U     T    112
      R    Lampe 2
      =    Lampe 3

      U     T    112
      L     S5T#1S
      SE    T    113
      U     T    113
      R    Lampe 3
      =    Lampe4


      U     T    113
      L     S5T#1S
      SE    T    114
      U     T    114
      R     Lampe 4
      =     Lampe 5

      U     T    114
      L     S5T#1S
      SE    T    115
      U     T    115
      R    Lampe 5

Jetzt soll die Lampe blinken, bei der der Taster losgelassen wird UND von dort soll bei erneutem Betätigen das Lauflicht auch weitergehen.

Ist es besser hier die "TimerVersion" zu benutzen oder sinnvoller die "ZählerVersion"? Bzw. überhaupt möglich?

JoopB · 19 Januar 2017

Dan muste Sie die Zahler version brauchen und keine reset von Zahler machen wen taste nicht gedrukt ist.

Verstuurd vanaf mijn GT-I9301I met Tapatalk

Spucas Leicher · 19 Januar 2017

Alles klar!
Jetzt muss ich die Lampe nur noch blinken lassen, wenn der Taster wieder ausgeschaltet wird.
Bisher:

Code:

      U     Taster 1
      U    Taktmerker
      ZV    Z      1

      L     Z      1
      L     5
      >I    
      L     C#0
      S     Z      1





      L     Z      1
      L     1
      >=I   
      L     C#1
      =     "U06SeqD".Seq.User.Bit10



      L     Z      1
      L     2
      >=I   
      L     C#2
      R     "U06SeqD".Seq.User.Bit10
      =     "U06SeqD".Seq.User.Bit11

      L     Z      1
      L     3
      >=I   
      L     C#3
      R     "U06SeqD".Seq.User.Bit11
      =     "U06SeqD".Seq.User.Bit12

      L     Z      1
      L     4
      >=I   
      L     C#4
      R     "U06SeqD".Seq.User.Bit12
      =     "U06SeqD".Seq.User.Bit13

      L     Z      1
      L     5
      >=I   
      L     C#5
      R     "U06SeqD".Seq.User.Bit13
      =     "U06SeqD".Seq.User.Bit14


      U     "U06SeqD".Seq.User.Bit10
      =     Lampe 1

      U     "U06SeqD".Seq.User.Bit11
      =    Lampe 2

      U     "U06SeqD".Seq.User.Bit12
      =    Lampe 3

      U     "U06SeqD".Seq.User.Bit13
      =     Lampe 4


      U     "U06SeqD".Seq.User.Bit14
      =    Lampe 5

Ich gehe davon aus, dass ich das mit einem Taktmerker umsetzen muss. D.h.:

Code:

UN Taster 1
U M 100.7  // Taktmerker bei 100 eingestellt
= Ausgang

Nur welchen Ausgang setze ich jetzt?

PinkPanther32 · 19 Januar 2017

Welche Lampe willst du den Blinken lassen beim ausschalten? und wie soll Die Lampe/Lampen blinken?

Spucas Leicher · 19 Januar 2017

Die Lampe, die zur Zeit noch (mit obigem Code) leuchtet, wenn ich Taster 1 loslasse.
Am Besten mit 1Hz, sprich M100.5 (Taktmerker).

Aufgabenstellung: Solange der Taster 1 gedrückt ist, sollen 5 Lampen nacheinander aufleuchten. Immer wieder von vorne, bis der Taster losgelassen wird.
Dann muss dort, wo zuletzt die Lampe geleuchtet hat, diese blinken, bis der Taster erneut betätigt wird.

PinkPanther32 · 19 Januar 2017

und bit + taster
oder
bit und nicht taster und blinktakt

= lampe

PN/DP · 19 Januar 2017

Spucas Leicher schrieb:
Aufgabenstellung: Solange der Taster 1 gedrückt ist, sollen 5 Lampen nacheinander aufleuchten. Immer wieder von vorne, bis der Taster losgelassen wird.
Dann muss dort, wo zuletzt die Lampe geleuchtet hat, diese blinken, bis der Taster erneut betätigt wird.

Bei Ausgangsansteuerungen mit Zusatz-Bedingungen trenne am besten den Weiterschalt-Ablauf (die Schrittkette, hier ist der Zähler die Schrittkette) und die Lampen-Ansteuerungen. Programmiere den Ablauf für sich und programmiere die Lampenansteuerung für sich.

Code:

//*** Ablauf Lauflicht ***
      U     #Taster
      U     #Schiebetakt
      ZV    Z1

      L     Z1
      L     5
      >I
      L     C#0
      S     Z1          //(Zähler auf 1 setzen, siehe KOP-Hilfe zu "Z_VORW")

//*** Lampen ***
//Die Verknüpfung "Blinken bei Taster=Aus und Dauerlicht bei Taster=Ein" wird mehrmals gebraucht, 
//deshalb zur Vereinfachung vorverknüpfen und auf einen Hilfsmerker speichern
      O     #Blinktakt
      O     #Taster
      =     #Lampenbit

      U(
      L     Z1
      L     1
      ==I               //==I: einzelne Lampe läuft durch / >=I: Lampenbalken baut sich auf
      )
      U     #Lampenbit  //Blinken oder Dauerlicht
      =     #Lampe1
...
      U(
      L     Z1
      L     5
      ==I
      )
      U     #Lampenbit
      =     #Lampe5

PS: Gewöhne Dir die vielen verstreuten S und R wieder ab, die machen das Programm nur undurchsichtig, fehleranfällig und erschweren ungemein eventuelle Programmänderungen.

Harald

Step 7 Lauflicht

Level-1

Level-1

Level-1

Level-1

Level-1

Level-1

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-1

User des Jahres 2014

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-1

User des Jahres 2014

User des Jahres 2011-2013; 2015-2017; 2020-2022

Level-1

Level-2

Level-1

Level-2

Level-1

Level-2

User des Jahres 2011-2013; 2015-2017; 2020-2022

Similar threads

Wir schützen deine Privatsphäre