Ampelkreuzung

Hambi

Level-1
Beiträge
6
Reaktionspunkte
0
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo!
Habe folgendes Problem: Ich bin ein blutiger Anfänger beim SPS programmieren. Ich habe mich erst seit kurzem in die Thematik eingelesen und mir intensiv alle Befehle durchgelesen. Zeitfunktionen habe ich in der Theorie verstanden.
Daher wollte ich mich an meine erste Schaltung ranwagen: Die Ampelkreuzung besteht aus einer dreifarbigen Autoampel und einer zweifarbigen Fußgängerampel.
Wenn der Fußgänger E0.2 drückt, wird nach einer Wartezeit die Autoampel von grün auf gelb auf rot auf rotgelb und wieder zurück auf grün geschaltet - die Fußgängerampel schaltet von rot auf grün und wieder zurück auf rot.
Soviel zu den theoretischen Rahmenbedingungen.
Mein erstes praktisches Problem ist, soll ich nach abgelaufener Timerzeit T dann auf UN T abfragen oder soll ich über die negative Flanke von T (also FN T) abfragen?
Mein zweites Problem ist, sind die Befehle SE und SS austauschbar? Spontan würde ich sagen, dass nur SS zum Einsatz kommt, weil der ja "nicht so leicht verloren gehen kann", sprich SS ist 00 resistent.
Ich habe eigentlich alles über die Befehle U T, UN T, SI und SS gemacht.
Mein drittes Problem ist, dass ich mit den Sprungbefehlen nicht klar komme, obwohl ich die der Theorie nach verstanden habe. Ich habe SPB für VKE=1 und SPBN für VKE=0 verwendet. Aber irgendwie hakt der Simulator :x:confused:!!
Hier ist der Quellcode:



a: U E 0.0 // Start
SPBN b


S A 1.0 // rot (Fußgänger) an
R A 1.1 // grün (Fußgänger) aus


R A 1.2 // rot (Auto) aus
R A 1.3 // gelb aus
S A 1.4 // grün (Auto) an


b: U E 0.1 // CLEAR
CLR


U E 0.2 // Fußgänger Button
SPBN a
L S5T#20S
SS T 1 // Setzen Speicher-Eingabe-Verzögerung = Timer1 = 20s


UN T 1
L S5T#3S
SI T 2 // Setzen Impuls Gelbphase = Timer2 = 3s
U T 2
R A 1.4 // grün (Auto) geht aus
S A 1.3 // gelb geht an


UN T 2
R A 1.3 // gelb geht aus
L S5T#10S
SI T 3 // Setzen Impuls Rotphase (Auto) = Timer3 = 10s
U T 3
S A 1.2 // rot (Auto) geht an


L S5T#4S
SS T 4 // Setzen Speicher-Eingabe-Verzögerung = Timer4 = 4s
UN T 4
L S5T#10S
SI T 5 // Setzen Impuls Grünphase (Fußgänger) = Timer5 = 10s
U T 5
R A 1.0 // rot (Fußgänger) geht aus
S A 1.1 // grün (Fußgänger) geht an


UN T 5
R A 1.1 // grün (Fußgänger) geht aus
S A 1.0 // rot (Fußgänger) geht an


L S5T#4S
SS T 6 // Setzen Speicher-Eingabe-Verzögerung = Timer6 = 4s
UN T 6
L S5T#3S
SI T 7 // Setzen Impuls Rotgelbphase = Timer7 = 3s
U T 7
S A 1.3 // rot (Auto) bleibt an; gelb geht zu rotgelb an
UN T 7
SPB a
 
1. Eine SPS arbeitet zyklisch. Das bedeutet, ist si am Programmende angelangt, fängt sie automatisch vorn wieder an. Deine Rücksprünge auf a würden dafür sorgen, dass die SPS ihren Zyklus nie beendet. Das überwacht diese aber und wirft dir nach einer eingestellten Überwachungszeit einen Zykluszeitfehler. Also, nicht nach "oben" zu a, sondern a ganz unten als letzte Anweisung und dann dorthin springen.

2. Zeiten niemals überspringen. Zeiten sind ein besonderer Fall in der SPS. Für dich als Anfänger ist der einfachste Weg, Zeiten so im Programm zu platzieren, dass sie immer abgearbeitet werden. Wenn du a ganz hinten im Programm stehen hast, kannst du die Zeiten dahinter anordnen. Dann wird entweder das Programm komplett abgearbeitet und landet bei a oder du springst und landest auch bei a. Danach werden die Zeiten bearbeitet und dann fängt das Programm wieder vorn an. Willst du eine Zeit laufen lassen, dann setze dir einen Merker.

U M100.0

L S5T#20S
SE T 100

So lange M100.0 True ist läuft die Zeit ab.
Ist M100.0 20 Sekunden lang True, wechselt T100 auf True.
Ist M100.0 False, ist sofort auch T100 False.

SPB erfolgt bei VKE = 1

U T100
SPB M001 //springt zur Marke M001, wenn T100 True ist.

U T101
SPBN M002 //springt zur Marke M002 wenn T101 False ist.

Identisch dazu wäre:

UN T101
SPB M002
 
Zuletzt bearbeitet:
Sorry, habe eigentlich nicht viel verstanden.
Zyklische Bearbeitung? Das heißt, ich brauche eigentlich fast keine Sprungbefehle (es sei denn ich will nach unten einen Absatz überspringen)?
Nicht nach oben springen, ok das ist machbar.
Aber das mit den Merkern, ich versteh`nur Bahnhof :confused:!
Ich dachte immer diese speziellen Merker wie M100.0 wären nur ein Kürzel für einen symmetrischen Taktgeber (mit einer jeweils ganz bestimmten Taktfrequenz).
Ist das nicht so? Je nachdem welche Zahl nach dem Punkt steht, hat man die Hertzzahl.
Bislang habe ich als Merker immer nur M0.0... M0.9 verwendet.
Wenn ich Dich richtig verstanden habe, ich rufe dann nicht mehr den Timer direkt auf, sondern indirekt über den dazugehörigen Merker.
Dann muss ich ja wohl vorher definieren:
U T1
= M0.1
U T2
= M0.2
usw.

Das mit True und False habe ich schnell verstanden (habe solide Vorkenntnisse in Digitaltechnik und bin auch mit Boolscher Algebra vertraut).
Der Simulator hakt aber immer noch :x:confused:!

Kann jetzt z.B. U M0.7 positiv aufrufen und sagen, solange der Merker high ist, läuft der Timer T7 noch.
Sobald aber der Merker low wird, hat der Timer fertig :p.
Sprungbefehle kann ich in Abhängigkeit des Merkers setzen.
SPB bei Merker high und SPBN bei Merker low.

Ich weiß nicht, woran`s liegt, aber der Simulator will einfach net :x.


U E 0.0 // Start
SPBN a


S A 1.0 // rot (Fußgänger) an
R A 1.1 // grün (Fußgänger) aus


R A 1.2 // rot (Auto) aus
R A 1.3 // gelb aus
S A 1.4 // grün (Auto) an


U E 0.1 // CLEAR
a: CLR


U T 1
= M 0.1
U T 2
= M 0.2
U T 3
= M 0.3
U T 4
= M 0.4
U T 5
= M 0.5
U T 6
= M 0.6
U T 7
= M 0.7






U E 0.2 // Fußgänger Button
L S5T#20S
SS T 1 // Setzen Speicher-Eingabe-Verzögerung = Timer1 = 20s


UN M 0.1
L S5T#3S
SI T 2 // Setzen Impuls Gelbphase = Timer2 = 3s
U M 0.2
R A 1.4 // grün (Auto) geht aus
S A 1.3 // gelb geht an


UN M 0.2
R A 1.3 // gelb geht aus
L S5T#10S
SI T 3 // Setzen Impuls Rotphase (Auto) = Timer3 = 10s
U M 0.3
S A 1.2 // rot (Auto) geht an


L S5T#4S
SS T 4 // Setzen Speicher-Eingabe-Verzögerung = Timer4 = 4s
UN M 0.4
L S5T#10S
SI T 5 // Setzen Impuls Grünphase (Fußgänger) = Timer5 = 10s
U M 0.5
R A 1.0 // rot (Fußgänger) geht aus
S A 1.1 // grün (Fußgänger) geht an


UN M 0.5
R A 1.1 // grün (Fußgänger) geht aus
S A 1.0 // rot (Fußgänger) geht an


L S5T#4S
SS T 6 // Setzen Speicher-Eingabe-Verzögerung = Timer6 = 4s
UN M 0.6
L S5T#3S
SI T 7 // Setzen Impuls Rotgelbphase = Timer7 = 3s
U M 0.7
S A 1.3 // rot (Auto) bleibt an; gelb geht zu rotgelb an


UN M 0.7
S A 1.0 // rot (Fußgänger) an
R A 1.1 // grün (Fußgänger) aus


R A 1.2 // rot (Auto) aus
R A 1.3 // gelb aus
S A 1.4 // grün (Auto) an
 
OT:
Benutze für Deinen Code bitte die Code-Tags, die durch einen Druck auf den letzten Button (#) der 2. Icon-Reihe erzeugt werden.
Dadurch wird der Code wesentlich lesbarer. Unter anderem dadurch, dass so auch Einrückungen erzeugt werden können:
Code:
...

[COLOR=#333333]     U    E 0.1     // CLEAR [/COLOR]
[COLOR=#333333]a:   CLR
[/COLOR]
...
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Wenn man die Ampel so programmiert, da kommt doch alles
nacheinandner, und dann fängt es wieder von vorne an, wo
willst Du da hinspringen? Als warum überhaupt ein Sprungbefehl?

"Zustandsautomat" wäre das richtige Stichwort.
 
Da bewegt sich jetzt gar nix mehr im Simulator.


Code:
[COLOR=#333333]U E 0.0 // Start [/COLOR]
[COLOR=#333333]SPBN a[/COLOR]

[COLOR=#333333]S A 1.0 // rot (Fußgänger) an [/COLOR]
[COLOR=#333333]R A 1.1 // grün (Fußgänger) aus [/COLOR]

[COLOR=#333333]R A 1.2 // rot (Auto) aus [/COLOR]
[COLOR=#333333]R A 1.3 // gelb aus [/COLOR]
[COLOR=#333333]S A 1.4 // grün (Auto) an [/COLOR]

[COLOR=#333333]U E 0.1 // CLEAR [/COLOR]
[COLOR=#333333]a: CLR[/COLOR]

[COLOR=#333333]U T 1[/COLOR]
[COLOR=#333333]= M 0.1[/COLOR]
[COLOR=#333333]U T 2[/COLOR]
[COLOR=#333333]= M 0.2[/COLOR]
[COLOR=#333333]U T 3[/COLOR]
[COLOR=#333333]= M 0.3[/COLOR]
[COLOR=#333333]U T 4[/COLOR]
[COLOR=#333333]= M 0.4[/COLOR]
[COLOR=#333333]U T 5[/COLOR]
[COLOR=#333333]= M 0.5[/COLOR]
[COLOR=#333333]U T 6[/COLOR]
[COLOR=#333333]= M 0.6[/COLOR]
[COLOR=#333333]U T 7[/COLOR]
[COLOR=#333333]= M 0.7[/COLOR]

[COLOR=#333333]U E 0.2 // Fußgänger Button [/COLOR]
[COLOR=#333333]L S5T#20S[/COLOR]
[COLOR=#333333]SS T 1 // Setzen Speicher-Eingabe-Verzögerung = Timer1 = 20s [/COLOR]

[COLOR=#333333]UN M 0.1[/COLOR]
[COLOR=#333333]L S5T#3S[/COLOR]
[COLOR=#333333]SI T 2 // Setzen Impuls Gelbphase = Timer2 = 3s [/COLOR]
[COLOR=#333333]U M 0.2[/COLOR]
[COLOR=#333333]R A 1.4 // grün (Auto) geht aus [/COLOR]
[COLOR=#333333]S A 1.3 // gelb geht an [/COLOR]

[COLOR=#333333]UN M 0.2[/COLOR]
[COLOR=#333333]R A 1.3 // gelb geht aus [/COLOR]
[COLOR=#333333]L S5T#10S[/COLOR]
[COLOR=#333333]SI T 3 // Setzen Impuls Rotphase (Auto) = Timer3 = 10s [/COLOR]
[COLOR=#333333]U M 0.3[/COLOR]
[COLOR=#333333]S A 1.2 // rot (Auto) geht an [/COLOR]

[COLOR=#333333]L S5T#4S[/COLOR]
[COLOR=#333333]SS T 4 // Setzen Speicher-Eingabe-Verzögerung = Timer4 = 4s [/COLOR]
[COLOR=#333333]UN M 0.4[/COLOR]
[COLOR=#333333]L S5T#10S[/COLOR]
[COLOR=#333333]SI T 5 // Setzen Impuls Grünphase (Fußgänger) = Timer5 = 10s [/COLOR]
[COLOR=#333333]U M 0.5[/COLOR]
[COLOR=#333333]R A 1.0 // rot (Fußgänger) geht aus [/COLOR]
[COLOR=#333333]S A 1.1 // grün (Fußgänger) geht an [/COLOR]

[COLOR=#333333]UN M 0.5[/COLOR]
[COLOR=#333333]R A 1.1 // grün (Fußgänger) geht aus [/COLOR]
[COLOR=#333333]S A 1.0 // rot (Fußgänger) geht an [/COLOR]

[COLOR=#333333]L S5T#4S[/COLOR]
[COLOR=#333333]SS T 6 // Setzen Speicher-Eingabe-Verzögerung = Timer6 = 4s [/COLOR]
[COLOR=#333333]UN M 0.6[/COLOR]
[COLOR=#333333]L S5T#3S[/COLOR]
[COLOR=#333333]SI T 7 // Setzen Impuls Rotgelbphase = Timer7 = 3s [/COLOR]
[COLOR=#333333]U M 0.7[/COLOR]
[COLOR=#333333]S A 1.3 // rot (Auto) bleibt an; gelb geht zu rotgelb an [/COLOR]

[COLOR=#333333]UN M 0.7[/COLOR]
[COLOR=#333333]S A 1.0 // rot (Fußgänger) an [/COLOR]
[COLOR=#333333]R A 1.1 // grün (Fußgänger) aus [/COLOR]

[COLOR=#333333]R A 1.2 // rot (Auto) aus [/COLOR]
[COLOR=#333333]R A 1.3 // gelb aus [/COLOR]
[COLOR=#333333]S A 1.4 // grün (Auto) an[/COLOR]
 
Das mit den Timern hast du nicht ganz richtig verstanden, funktioniert aber.

Es ging darum:

Ein Timer benötigt zum Start imer eine Wertänderung (sprich positive Flanke) am Start-Eingang.
Wenn man Timer umspringt, kann es passieren, dass man genau diese Wertänderung nicht mitbekommt.
Dann ist der Merker, der den Timer startet True, aber der Timer läuft nciht los.
Wenn du keine Sprünger über Timer hinweg hast (ist jetzt so) funzt das.

Was du getan hast, ist aber auch durchaus sinnvoll, denn Timer haben die Eigenheit (da Hardwaretimer) jederzeit im Programm abzulaufen.
Wenn also die 10 Sekunden um sind, schaltet der Timer, unabhängig davon, wo dein Programm gerade in der Bearbeitung ist.
Das sieht dann so aus:

Du hast einene Timer, diesen Timer nutzt du direkt in einem großen Programm, einmal am Anfang, enmal am Ende.
Nun läuft der Timer mitten im Programm ab. Dann hast du am Anfang des Programms den Timer auf False gehabt, am Ende auf True.
Kann (kann) im Programm zu Problemem führen. Der Merker, den du an den Ausgang des Timers setzt, verhindert das.
Er ändert seinen Wert, in dem Moment, in dem dein Programm gerade am Timer ist und bleibt dann solange auf diesem Wert, bis das Programm wieder am Timer "vorbeikommt".

Zu deinem Programm:

Such dir doch mal hier im Forum über das Stichwort "Schrittkette" Informationen zum Thema. Auch "Ampel" oder "Ampelschaltung" fördert viele Beiträge zu Tage.
 
Bin total verwirrt :confused:!
Schlagwort Schrittkette ist vielleicht gar nicht so schlecht:


Code:
       U    E         0.2                // Fußgänger Button         
       L    S5T#20S
       SS   T         1                  // Setzen Speicher-Eingabe-Verzögerung = Timer1 = 20s   

       UN   T         1
       U    M       100.0
       L    S5T#3S
       SI   T         2                  // Setzen Impuls Gelbphase  = Timer2 = 3s   
       U    T         2
       U    M       100.0
       R    A         1.4                // grün (Auto) geht aus   
       S    A         1.3                // gelb geht an


Ich drücke E0.2 (Fußgänger Button).
Der Timer T1 läuft an 20s abwärts auf Null - soweit so gut, kann ich beobachten.
Aber der verflixte Timer T2 startet nicht :-:)-x!

T2 müsste direkt nachdem T1 fertig hat :p, loslaufen - tut aber net :confused:!

Ist vielleicht folgende Verknüpfung nicht richtig?

Code:
UN   T         1
U    M       100.0

Das ist meine Startbedingung für T2.
Ich dachte M100.0 würde T1 in seinem Rasterdurchlauf solange abtasten, bis es feststellt, T1 hat gerade fertig :p (negative Flanke).
Die Flanke darf natürlich nicht verpasst werden (logo :cool:), daher nehme ich einen Taktmerker mit nicht zu kleiner Taktfrequenz (M100.0 müsste mit 10 Hz eigentlich schnell genug sein)

Also wie gesagt T2 läuft net an.

Wenn ich meine Timer beobachten will, isses doch wohl sinnvoll, die nicht durch einen normalen Merker M0.1 zu ersetzen oder nicht?
Weil soviel ich weiß, kann ich Merker nicht beobachten, die arbeiten quasi undercover :p.
 
Zuletzt bearbeitet:
Zuviel Werbung?
-> Hier kostenlos registrieren
... dann versuch es doch mal, es als Schrittkette zu entwerfen ...
Ich fürchte, dass du mit deinem aktuellen Ansatz sonst nicht wirklich weiter kommst - und es hilft dir auch gar nichts, weil man gerade solche Abläufe im "wirklichen Leben" auch tatsächlich als Schrittkette umsetzt ...

Gruß
Larry
 
Das ist meine Startbedingung für T2.
Ich dachte M100.0 würde T1 in seinem Rasterdurchlauf solange abtasten, bis es feststellt, T1 hat gerade fertig :razz: (negative Flanke).
Die Flanke darf natürlich nicht verpasst werden (logo :cool:), daher nehme ich einen Taktmerker mit nicht zu kleiner Taktfrequenz (M100.0 müsste mit 10 Hz eigentlich schnell genug sein)

Wenn ich das richtig verstehe hast du sobald dein T1 abgelaufen ist, einen 100ms Trigger am Eingang deines T2...

Hier mal ein kurzer Auszug aus der Funktionsbeschreiben des SI

Wenn das Signal am Setzeingang von 1 auf 0 wechselt, nachdem das Zeitglied gesetzt wurde und die eingestellte Zeit noch nicht abgelaufen ist, wird das Zeitglied gestoppt, der Ausgang hat das Signal 0 und über die Ausgänge DUAL und DEZ kann die Restlaufzeit abgefragt werden. Bei einem erneuten Wechsel des Setzeingangs von 0 auf 1 beginnt die komplette Zeit abzulaufen und nicht nur die Restlaufzeit, die beim Signalwechsel von 1 auf 0 übrig war.

Wenn du also dein SI im 100ms Takt triggerst, kann der meiner bescheidenen Meinung nach gar nicht loslaufen? :confused:


Gruß ThomasM
 
Bin leider trotz stundenlangem Kämpfens nicht weitergekommen :x:-(!
Mein Mitbewohner riet mir das ganze über Unterprogramme zu lösen.
Mit CALL kann man Bausteine aufrufen, das weiß ich, aber das führt dann schon in das Gebiet der nicht-linearen Programmierung.
Ich kenne ja noch nicht einmal die Unterschiede zwischen den einzelnen Bausteintypen, geschweige denn wie man wieder zurück ins Hauptprogramm kommt.
Gibt es da auch sowas wie einen Return Befehl?
Wie zum Geier soll ich nur eine Steuerung programmieren, wenn die SPS nicht schön brav sukzessive von Timer zu Timer geht :confused:?
Die SPS pflügt ja nur so durch alles durch, so dass sich meine Timer dann gegenseitig verhaken...

Stichwort Flanken antriggern ist mir noch eine Idee gekommen:

Code:
       UN   T         1
       FN   M         0.1
       L    S5T#3S
       SI   T         2                  // Setzen Impuls Gelbphase  = Timer2 = 3s   
       U    T         2
       FP   M         0.2
       R    A         1.4                // grün (Auto) geht aus   
       S    A         1.3                // gelb geht an

Würde das so funktionieren? Dass erst T1 negativ angetriggert wird und danach T2 positiv?
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Bin leider trotz stundenlangem Kämpfens nicht weitergekommen :x:-(!

Da du ja sehr beratungsresistent bist hast du es auch nicht besser verdient.
Vielleicht als Tip : auf dem Weg, den du da jetzt verfolgst, kannst du dich noch bis zum Sankt-Nimmerleinstag beschäftigen. Vielleicht funktioniert es dann auch irgendwann so la-la ... aber wehe, wenn du dann mal etwas daran ändern willst.
Aber es ist dein Spiel - wem nicht zu raten ist dem ist auch nicht zu helfen ...

Gruß
Larry
 
Da du ja sehr beratungsresistent bist hast du es auch nicht besser verdient.
Vielleicht als Tip : auf dem Weg, den du da jetzt verfolgst, kannst du dich noch bis zum Sankt-Nimmerleinstag beschäftigen.

@ Larry Laffer: Schon gewusst? Wir haben heute "Sankt Nimmerleinstag" :razz:!
Habe nach 12 stündiger Schlacht das Problem lösen können!
Die Internet Recherche hat nix ergeben. Das waren entweder ganz andere Schaltungen oder nur Fragmente, mit denen ich nix anfangen konnte.

Zur Lösung:
Ich habe einen 1Hz Taktgeber zu Fuß eingegeben (der automatische mit M100.1 hat nicht funktioniert).
An diesen habe ich einen Zähler gekoppelt.
Ein Vergleichsoperator hält den Zähler an, wenn der jeweilige Sollwert (in Sek) erreicht ist und schaltet den Ausgabebefehl frei.
Ich habe zwei verschiedene Betriebsmodi, den Autofahrerbetrieb und den Fußgängerbetrieb.
Der Autofahrerbetrieb enthält die Startbedingungen, der Fußgängerbetrieb führt in die Zählschleife.
E0.0 macht Zähler Start/Stop (Fußgängerbetrieb).
E0.1 ist Zähler Reset (Autofahrerbetrieb).
In der Zählschleife müssen die Startbedingungen übersprungen werden.

Code:
 U    E         0.0                // Zähler Start/Stop = Fußgängerbetrieb


// Taktgeber 1Hz 
       U    T         1
       L    S5T#500MS
       SA   T         2
       U    T         2
       =    M         1.0
       UN   T         2
       L    S5T#500MS
       SE   T         1


       U    M         1.0
       ZV   Z         1
       L    Z         1
       L    1
       >=I
       SPB  a


// Startbedingungen 
       S    A         1.0                // rot (Fußgänger) an      
       R    A         1.1                // grün (Fußgänger) aus        
       R    A         1.2                // rot (Auto) aus        
       R    A         1.3                // gelb aus        
       S    A         1.4                // grün (Auto) an   


// Zählschleife 
a:     U    E         0.0
       U    M         1.0                // Taktgeber 1Hz 
       ZV   Z         1
       L    Z         1
       L    15
       ==I
       R    A         1.4                // grün (Auto) aus 
       S    A         1.3                // gelb an 


       U    E         0.0
       U    M         1.0
       ZV   Z         1
       L    Z         1
       L    18
       ==I
       R    A         1.3                // gelb aus 
       S    A         1.2                // rot (Auto) an 


       U    E         0.0
       U    M         1.0
       ZV   Z         1
       L    Z         1
       L    22
       ==I
       R    A         1.0                // rot (Fußgänger) aus 
       S    A         1.1                // grün (Fußgänger) an 


       U    E         0.0
       U    M         1.0
       ZV   Z         1
       L    Z         1
       L    30
       ==I
       R    A         1.1                // grün (Fußgänger) aus 
       S    A         1.0                // rot (Fußgänger) an 


       U    E         0.0
       U    M         1.0
       ZV   Z         1
       L    Z         1
       L    34
       ==I
       S    A         1.3                // gelb zu rotgelb an 


       U    E         0.0
       U    M         1.0
       ZV   Z         1
       L    Z         1
       L    37
       ==I
       R    A         1.2                // rot (Auto) aus 
       R    A         1.3                // gelb aus 
       S    A         1.4                // grün (Auto) an 


       L    Z         1
       L    37
       >I
       R    Z         1


b:     U    E         0.1                // Zähler Reset = Autofahrerbetrieb 
       R    Z         1

PS: So ein bisschen mehr Schützenhilfe hätte ich mir von diesem Forum ja schon erwartet!
Dazu kann ich gerne noch eine kleine Story erzählen.
Ich wollte ja mal Combo Makros für Streetfigher (PS3) programmieren, weil ich die manuell trotz stundenlangen Trainings nie hinbekommen habe.
Dafür habe ich mir einen ganz speziellen Mikrocontroller gekauft.
Das Problem war, ich verstand von Programmierung soviel wie der Papst vom Free Style Fighting :razz:.
Der einzige Befehl, den ich kannte war der Returnbefehl (der kam darin aber nicht vor).
Ich habe allein satte zwei Wochen gebraucht, um überhaupt mit der Bedienungsleiste der Software was anfangen zu können!
Vom Programmieren mal ganz zu schweigen!
Habe in meiner Not ein Forum aufgesucht (das aber leider nur englischsprachig war).
Nach zähem Schriftverkehr hat sich ein Mitglied "erbarmt" mir wenigstens den Header zu schreiben.
Von da an ging meine Combo Karriere steil nach oben :cool:!
Habe im Laufe der Zeit wirklich ganz tolle Combo Skripte verfasst, die sich in der Praxis (habe nur gegen die CPU gekämpft) auch sehr bewährt haben.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Manchmal muß man hier einfach schmunzeln.
Du hast hier wirklich alle Hinweise zum Lösen des Problems bekommen:
  • Eine SPS arbeitet zyklisch
  • Das Problem lässt sich am einfachsten mit einem Zustandsautomat bzw. einer Schrittkette lösen

Die Lösung, die du nun hier zeigst ist nichts anderes als eine Schrittkette mit einem Zähler.
 
Moin

Der ganze Schriftverkehr zeigt, da hat einer die Funktionsweise einer SPS nicht genau verstanden.

Hier wurde der Hinweis auf die "Basics" nicht ernst genommen.

Schade das es immer wieder so kommt.
Hatte auch das Problem mit IOT.
Junger Dynamischer "Jung Studierter" Da gehen wir auf die S7 und holen die Daten ab.
Der Kollege war dann ganz erstaunt Programm war anders als vom Maschinenhersteller.
Da war nix. In 10 Minuten haben wir die Daten
Gesendet von iPhone mit Tapatalk
 
1.

PS: So ein bisschen mehr Schützenhilfe hätte ich mir von diesem Forum ja schon erwartet!

Diese Aussage ist eine Frechheit.

2. Nochmal zurück zum Thema

Ich habe einen 1Hz Taktgeber zu Fuß eingegeben (der automatische mit M100.1 hat nicht funktioniert).

Hattest du die Taktmerker überhaupt in der HW-Konfig aktiviert? und auch auf das MB100 gelegt??

Gruß ThomasM
 
Zurück
Oben