Verschiedene Zeiten nacheinander an einem Timerbaustein

A

Anonymous

Guest
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo

ich bin noch recht unerfahren mit Step5 muss aber eine knifflige Aufgabe lösen. Ich arbeite mit einer S5-115U mit einer 941er CPU.

Ich möchte eine Speichernde Einschaltverzögerung SS nacheinander mit unterschiedlichen Zeiten "beschalten". Nun habe ich mir überlegt, diese Zeiten nacheinander in einen DB zu schreiben. Jetzt ist meine Frage: Wie kann ich diese Zeiten nacheinander abfragen und als Zeitwert laden.

Hier mein kleines Netzwerk:

Code:
1. Timer
U M 1.3           <-- Dieser Merker ist eine pos. Flankenauswertung eines Tasters (E0.0)
L M W30          <-- in dieses Merkerwort habe ich den Zeitwert, welcher variabel sein soll. am Besten 10 verschiedene Werte nacheinander.
SS T1
O E0.1
O M1.1
R T1

2. Timer am Ausgang des 1.
U T1
L MW 40
SV T2
U E0.1
R T2
= A4.3

Wenn ich nun den Taster das erste mal drücke soll der Timer zb KT 100.0 sein. Beim 2. Mal KT 150.0... Am besten Werte welche ich wie gesagt in einen DB vorher festlege und dann nacheinander dort "raushole"


Ich hoffe ich konnte mich verständlich ausdrücken und ihr könnt mir bei meinem Programm helfen.

Vielen Dank schon mal

Daniel
 
Hallo
Der einfachste (Holzhammermethode) ist wie folgt:

Da jedesmal eine neue Zeit geladen werden soll kannst Du, z.B. dein Trigger Signal für den Timer zusätzlich auf einen Zähler Legen:
Code:
u M 1.3
ZV Z1

Rücksetzbedindung für den zähler fehlt noch

Nun kommt das eigentliche
Code:
      A  DB 10

        L Z1
        L KC #1
        <>F
        SPB M001
         L DW0
        T MW 30
M001:L Z1
         L KC #2
        <>F

usw...

Ich hoffe, das ich nicht dem S7 Syntax ins Trudeln gekommen bin.



Der andere Weg ist über indirekte Adressierung zu lösen.
Dort würde man auch ein Zähler haben, in dem steht nun die Adresse, wo die Zeit liegt.
Code:
nur bei Pos. Flanke M1.3
L mw 32
L 1
+F
t MW 32

A DB 10
B mw32
L DW0
T MW32

Hier fehlt auch die Rücksetzbedingung , sowie die Überwachung der Grenzen. Wird MW32 (Zählvariable) zu groß, so geht (ohne FehlerOB) die S5 in Stop.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
hallöchen

also da du sicher nicht indirekt programmieren willst hier eine einfache lösung

Code:
u ..... // ereigniss wenn umgeschaltet werden soll
L mb 20
L 0
==F
spb m001
spa nex1

m001:L 2
t mb 20
L MW ...                 // deine zahl was du ins mw 30 schreiben willst
t mw 30

nex1: u ..... // ereigniss wenn umgeschaltet werden soll
L mb 20
L 1
==F
spb m002
spa nex2

m002:L 3
t mb 20
L MW ...                 // deine zahl was du ins mw 30 schreiben willst
t mw 30

usw usw

nex9:u ..... // ereigniss wenn umgeschaltet werden soll
L mb 20
L 10
==F
spb m010
spa nex1

m010:L 0              // wieder von 0 weg
t mb 20
L MW ...                 // deine zahl was du ins mw 30 schreiben willst
t mw 30
be

noch eins vorweg ich weis im moment nicht auswendig ob gleichprüfung auf == oder != geht zulange her

und bitte in einen fb programmieren
 
Hallo,

hier eine Lösung, die mit der indirekten Adressierung arbeitet.
Etwas schwierig könnte der 'Bearbeite - Befehl' sein.
Dazu bitte die Doku lesen.
In diesem Beispiel wird beim wiederholten Drücken des
Tasters die Zeit mit dem nächsten Wert sofort gestartet.
Will man das vermeiden, könnte man vor dem Sprung
noch ' ON A32.0 '( Timer läuft ) schreiben.


Code:
Netzwerk 1 von 1                                                 Bib =                                                          
     :A    DB  10            DB oeffnen 
                                                                                       
     :UN   M   32.0         keine Flanke erkannt
                                  dann Sprung zum (<---evtl.: ON A32.0 )  
     :SPB  =M001          Timeraufruf 
     :                          ----------------
     :U    T   10           Wenn Zeit laueft
     :R    T   10           dann reset Timer 
     :R    A   32.0        reset done-bit 
     :                          
     :L    MW  20           Index laden und 
     :L    KF   1             um 1 erhoehen  
     :+F        
     :T    MW  20           pruefen auf Maxwert
     :L    KF  10            Max = 9 (10 Werte Dw0 - DW9 )       
     :<F                       wenn kleiner dann 
                                                   
     :SPB  =M001            Sprung zum Timeraufruf
                      
     :L    KF   0              sonst: 
     :T    MW  20           Index auf Anfang setzen 
                                            
M001 :
     :U    M   32.0         pos. Flanke Taster
     :B    MW  20          ! Bearbeite Index    
     :L    DW   0           L DW [Index]   
     :   
     :SS   T   10           starte Timer
     :U    T   10           Timer ist abgelaufen 
     :=    A   32.0         done-bit ( test = A32.0 )  
    
     :BE                                                                                        
// DB10
                                                                                              
      0:     KT = 100.0;
      1:     KT = 200.0;
      2:     KT = 300.0;
      3:     KT = 400.0;
      4:     KT = 500.0;  
      5:     KT = 600.0;  
      6:     KT = 700.0;
      7:     KT = 800.0; 
      8:     KT = 900.0;
      9:     KT = 100.1;
     10:     KT = 200.1;

mfg.

Rolf
 
Vielen Dank!

:D Super vielen Dank für eure ausführliche Hilfe! Ich habe mich für kpeters Lösung entschieden!

Besten Dank nochmal! Falls ihr mal in Nürnberg seid, lade ich euch auf ne halbe Bier ein! Einfach ne Private Message schreiben

mfg
Daniel
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hallo!
Ich muss mein Programm noch erweitern und möchte an mehreren verschiedenen Timerbausteinen (80 St.) nacheinander die Werte aus einem DB entnehmen (am besten festgelegt durch einen Zähler. Zähler = 0 --> öffne DW0. Danach Zähler +1, dass das nächste mal DW1 geladen wird.

Deswegen ich hätte noch ein paar Fragen zu folgendem Programmbeispiel

Code:
Netzwerk 1 von 1                                                 Bib =                                                         
     :A    DB  10            DB oeffnen
                                                                                       
     :UN   M   32.0         keine Flanke erkannt
                                  dann Sprung zum (<---evtl.: ON A32.0 ) 
     :SPB  =M001          Timeraufruf
     :                          ----------------
     :U    T   10           Wenn Zeit laueft
     :R    T   10           dann reset Timer
     :R    A   32.0        reset done-bit
     :                         
     :L    MW  20           Index laden und
     :L    KF   1             um 1 erhoehen 
     :+F       
     :T    MW  20           pruefen auf Maxwert
     :L    KF  10            Max = 9 (10 Werte Dw0 - DW9 )       
     :<F                       wenn kleiner dann
                                                   
     :SPB  =M001            Sprung zum Timeraufruf
                     
     :L    KF   0              sonst:
     :T    MW  20           Index auf Anfang setzen
                                           
M001 :
     :U    M   32.0         pos. Flanke Taster
     :B    MW  20          ! Bearbeite Index   
     :L    DW   0           L DW [Index]   
     :   
     :SS   T   10           starte Timer
     :U    T   10           Timer ist abgelaufen
     :=    A   32.0         done-bit ( test = A32.0 ) 
   
     :BE

Ich denke mal
:UN M 32.0 keine Flanke erkannt
soll die Flanke für die umschaltung sein!? Stimmt das?

Für was braucht man folgenden Abschnitt?
:U T 10 Wenn Zeit laueft
:R T 10 dann reset Timer
:R A 32.0 reset done-bit

Warum ist da ein Timer?

Irgendwie hab ich das noch nicht so ganz verstanden, kann mir das bitte jemand etwas ausführlicher erklären?

Vielen Dank schon mal!

Daniel
 
Zurück
Oben