2. Tipps und
Tricks Teil 3 (Stand: 10.12.2010)
Bedienungsanleitung
und Befehlsliste können beim Programmieren am PC mit Taste F1 aufgerufen
werden.
Zeittakte mit Uhrzeit und TIMER, Wartezeit,
(Schaltuhr siehe Softwarebausteine)
Weiter zu Tipps und Tricks Teil 4
zurück zu Tipps_und_Tricks_Teil_2
Inhaltsverzeichnis
Überschreitung von 32767 beim Rechnen, Begrenzen
Zählen_bis_65535 im word, Zahl 0 bis 65535, Anzeigen mit 1 bis 2 Kommastellen
Zahlen_über_65535 Zähler, Addition, Multiplikation, Division NEU
Es
gibt nur einfache Lösungen. Einziges Problem:
Man muss sie finden.
(Robert M. Pirsig, amerik. Schriftsteller)
2.3) Zeitmessung und Bildung von Zeittakt
Für Wartezeit, Überwachungszeit, usw. werden Zeit-Impulse benötigt. Die Impulse stehen nur während eines Programmdurchlaufs.
Anwendung:
If not Minpuls then goto weiter
Programmteil wird nur einmal je Minute bearbeitet, z.B. Zaehler = Zaehler +1
#weiter
Im folgenden Teil werden
viele Möglichkeiten zur Erzeugung
von Zeit-Impulsen gezeigt.
Definitionen
Je nach gewähltem
Verfahren werden natürlich nicht alle Definitionen gebraucht.
define Wert12 word[4] ' = Byte 7,8 Zwischenspeicher
define wert1 byte [7] ' Zwischenspeicher
define wert1Bit0 Bit [49] ' für Bit-Handling des byte
wert1
define wert1Bit1 Bit [50]
define wert1Bit2 Bit [51]
define Bit81_88 byte [11] ' >>(Bit 81 bis 88)<<
define FlankeMinpuls Bit [81] ' Flankenbit
für Minuten-Takt
define
FlankeSekpuls Bit [82] ' Flankenbit
für 4-Sek-Takt
define Sek4puls Bit [83] ' Bit 4-Sekunden Impuls (15-mal
je Minute)
define Sek15puls Bit
[84] ' Bit
Impuls (viermal je Minute)
define Minpuls Bit [85] ' Bit Impuls (einmal je Minute)
define HalbMinpuls Bit [86]
' Bit Impuls (zweimal je Minute)
define ZweiMinpuls Bit
[87] ' Bit
Impuls (einmal je zwei Minuten)
define Neuwert byte [23] ' (Neuwert für
TIMER-Beispiel 10 und 12)
define Wartezeit byte [23]
' (= Neuwert für TIMER-Beispiele 10 und 12)
(define Neuwert word [12] )' (Neuwert für TIMER-Beispiele 11, ab 13)
define Wartezeit word [12] ' (= Neuwert für TIMER-Beispiele ab 13)
(1) Lösungen mit Uhrzeit direkte Abfrage (define)
(1) Arbeitet man mit Flanken-Bit, wird nur dieses einzelne Bit zusätzlich gebraucht.
MinPuls = OFF ' (Minuten-Impuls einmal je Programmdurchlauf)
if second < 5 then goto setz
Flanke = OFF ' Reset der
Flanke
Goto Ende11 '
#setz
if Flanke = ON then goto Ende11 'bei Ja, Minuten-Impuls bereits erfolgt
Flanke = ON 'Sperre
für einmalig je Minute
MinPuls = ON ' Minuten-Impuls einschalten
#Ende11
(2) Man kann auch ein Byte für die Flanke benutzen, hat dann aber 8 Bit „verbraucht“.
define Altminute byte
if Altminute = minute then goto Ende21
Altminute = minute
(Programm an dieser Stelle wird nur einmal je Minute
durchlaufen)
#Ende21
(3) Weiteres Beispiel mit Byte
MinPuls = OFF ' (Minuten-Impuls einmal je Programmdurchlauf)
if Altminute = minute then goto Ende31
Altminute = minute
MinPuls = ON ' Minuten-Impuls einschalten
#Ende31
(4) Weiteres Beispiel: 4 Impulse je
Stunde z.B. für Datenloggen alle 15 Minuten
if minute=0 or minute=15 or
minute=30 or minute=45 then goto Logg
Flanke = OFF ' Reset der
Flanke
Goto Ende41 'kein
Datenloggen
#Logg
if Flanke = ON then goto Ende41 'bei Ja, Datenloggen bereits erfolgt
Flanke = ON 'Sperre
wegen Datenloggen nur einmalig je 15 Minuten
(z.B. Programmteil Datenloggen oder Sek15Puls = ON)
#Ende41
(2) Lösung mit Uhrzeit und Bitwert
Minute oder Second wird auf wert1 gelegt. Nun können die
Bits abgefragt werden.
Folgende Zeitimpulse können mit den Bits gewählt werden bei wert1 = second:
Bit0 (1
sec), Bit1 (2 sec), Bit2 (4 sec), Bit3 (8 sec), Bit4 (16 sec), Bit5 (32
sec).
Wird wert1 = minute programmiert, gelten die Bits für Minuten-Impulse.
Bit0 (1 min), Bit1 (2 min), Bit2
(4 min), Bit3 (8 min), Bit4 (16 min), Bit5 (32 min).
(1) Ein Zeitimpuls
Sek4puls =OFF' Reset Sekunden-Impuls nach einem
Programmdurchlauf
wert1 = second 'Uhrzeit
wird nach Byte geladen (Bit 2 wechselt alle 4 Sekunden, außer bei second=0)
if wert1Bit2 =
FlankeSekpuls then goto EndeSekpuls' wenn Wert1 Bit 2 gleich
Flankenmerker, dann „nichts tun“
FlankeSekpuls = wert1Bit2 ' andernfalls
Flankenmerker = Bitwert setzen
Sek4puls = ON ' Aufrufbit 14-mal je Minute (alle 4
sec außer bei scond = 0 )
#EndeSekpuls
Falls 15 Impulse je Minute
gebraucht werden, muss die folgende Variante teilweise benutzt werden.
(2) Mehrere Zeitimpulse mit nur einem Flankenmerker
Sek4puls = MinPuls '
bei 56 sec folgt zusätzlich (statt bei
0 sec) der 15. Impuls
Sek15puls = OFF : Minpuls = OFF : ZweiMinPuls =
OFF ' Reset Zeit-Impulse
wert1 = second
if wert1Bit2 = FlankeSekpuls then goto EndePuls' Bit 2 wechselt alle 4 Sekunden
FlankeSekpuls = wert1Bit2 'beide Flanken !!!
Sek4puls = ON '
Aufrufbit alle 4 sec außer bei 0 sec (siehe 1. Zeile), insgesamt 15 Impulse
je Minute
Das Folgende wird alle 4 sec durchlaufen. Dabei ist Bit 2 alle 8 sec EIN (4 sec Ein und 4 sec Aus) und Bit 3 ist alle 16 sec EIN.
Sek15puls =
wert1Bit2 and not wert1Bit3 ' EIN bei 4 sec , 20 , 36 und 52 sec
Die Halb-Minuten-Impulse erfolgen bei 4 sec und 36 sec. Bit
4 (16 sec) verhindert die anderen sek15-Impulse.
HalbMinPuls = sek15puls and not wert1Bit4 ' nur bei 4 sec und 36 sec
(HalbMinPuls = wert1Bit2
and not wert1Bit3 and not wert1Bit4 '
alternativ ohne sek15puls)
Der Minuten-Impuls erfolgt am Ende der Minute bei 56 sec,
sobald Bit 3/4/5 (=8+16+32) gesetzt sind.
MinPuls = wert1Bit3 and wert1Bit4 and wert1Bit5 ' nur bei 56 sec
Ein Zwei-Minuten-Impuls kann anschließend folgen.
wert1 = minute 'Uhrzeit
ZweiMinPuls = wert1Bit0 ' nur bei 56 sec und ungerader Minutenzahl (1, 3, 5, ...)
#EndePuls
(3) Lösung mit Uhrzeit (Sekunden-Bereich) (define)
Mit Sekundenbereichen können auch mehrere Impulse je Minute erzeugt werden.
Die Lage der Impulse innerhalb der Minute kann festgelegt werden (hier 5 sec und 35 sec).
Sie stehen jeweils nur für einen Programmdurchlauf an.
Es werden Sekunden-Bereiche benutzt für sicheres Schalten, auch wenn die Programmlaufzeit größer als 1 Sekunde ist.
Beispiel: Halbminuten-Impuls
HalbMinpuls = OFF ' Reset HalbMinuten-Impuls nach einem Programmdurchlauf
if (second > 5) and (second < 20) then goto setz ' Uhrzeit 5 Sekunden bis 20 Sekunden? Ja, dann Setzbefehl
if (second > 35) and (second < 50) then goto setz ' Uhrzeit 35 Sekunden bis 50 Sekunden? Ja, dann Setzbefehl
FlankeMinpuls = OFF ' andernfalls Reset Flanke
Goto Ende30
#setz
if (FlankeMinpuls = ON) then goto Ende30 ' Flanke Ein? Ja, dann Ende (HalbMinuten-Impuls wird nur einmal gesetzt!)
FlankeMinpuls = ON ' Setze Flanke (Sperre für weiteres Setzen)
HalbMinpuls = ON ' Aufrufbit zweimal je Minute
#Ende30
(4) Lösung mit Uhrzeit mit
MOD-Befehl (define)
Vorteil: Mit Änderung des
MOD-Befehls kann sehr einfach die Anzahl der Impulse je Minute geändert werden.
Mit einer Variablen statt fester Zahl kann sogar durch das
Programm (oder durch Eingabe) die Anzahl der Impulse geändert werden.
Beispiel: Die Minute wird durch 15 geteilt, z.B. bei
Uhrzeit 30 Minuten geteilt durch 15 bleibt kein Rest (minute MOD 15 = 0).
Mit minute MOD 15 = 0 erzeugt man 4 Zeit-Impulse je Stunde, also alle 15 Minuten einen Impuls,
nämlich bei Minute 0 , 15 , 30 , 45.
MOD 6 ergibt 10 Impulse, MOD 10
ergibt 6 Impulse, MOD 20 ergibt 3 Impulse, MOD 30 ergibt 2 Impulse und MOD 31
bis MOD 59 ergibt 1 Impuls je Stunde.
Beispiel Taktzahl bei
einer Regelung mit motorischem Stellventil,
die Variable wird durch die Soll-Ist-Abweichung bestimmt. Hat die Variable den Wert
15, wird second MOD 15 ausgeführt.
Mit second MOD 15 = 0 erzeugt man 4
Zeit-Impulse je Minute, usw. wie vor.
Second MOD 40 = 0 ergibt also 1 Impuls je Minute.
if minute MOD 15 = 0 then goto Logg ' Bei 0/15/30/45 bleibt kein Rest (Modulo)
Flanke = OFF ' Reset der
Flanke
Goto Ende 'kein
Datenloggen
#Logg
if Flanke = ON then goto Ende 'bei Ja, Datenloggen bereits erfolgt
Flanke = ON 'Sperre
wegen Datenloggen nur einmalig je 15 Minuten
(z.B. Programmteil Datenloggen oder Sek15Puls = ON)
#Ende
(5) Lösung mit Uhrzeit mit
MOD-Befehl (Sekunden-Bereich) (define)
Beispiel: Die Sekunde wird durch 30 geteilt, d.h. 2 Impulse
je Minute (bei 0 und bei 30 Sekunden).
Bei der Division bleibt ein Rest z.B. bei Uhrzeit 35
Sekunden geteilt durch 30 ist der Rest 5.
Im Zeitbereich 30 bis 35 wird die
Uhrzeit ausgewertet und führt zum sicheren Schalten, selbst wenn die Laufzeit
des Programms 4 sec beträgt.
if second MOD 30 =< 5 then goto Zaehler ' Bei 0 bis 5 und 30 bis 35 stimmt der Rest (Modulo)
Flanke = OFF ' Reset der
Flanke
Goto Ende 'nicht zaehlen
#Zaehler
if Flanke = ON then goto Ende 'bei Ja, Zaehlen bereits erfolgt
Flanke = ON 'Sperre
wegen Zaehlen nur einmalig je 30 Sekunden
Zaehler = Zaehler + 1
#Ende
(6) Lösung mit Timer-Bit und
Flanke (define)
Der Zeitimpuls (Bit Sekpuls) ist nicht synchronisiert zum eigenen Programm.
Der Timer ist freilaufend, d.h. die Timerbits sind nicht
synchronisiert.
Der Timer hat als Zeitmaß 20 msec für ON und 20 msec für
OFF bei Bit 0. Von ON bis zum folgenden ON sind es 40 msec.
Entsprechend ist Bit 1 im Abstand von 80 msec
eingeschaltet. Je Bit verdoppelt sich die Ein- und Ausschaltzeit.
Beispiel: Bit 6 (Bitwert 64) wird im
Abstand von 2,56 sec eingeschaltet (= 64 x 40 msec).
Sekpuls = OFF
wert1 = TIMER '(maskiert
auf ein Byte)
if wert1bit6 = ON then goto weiter1 ' BIT 6 des Timers ein? Bei JA, Impuls setzen
FlankeSekpuls = OFF : goto weiter2 ' (Flanke rücksetzen)
#weiter1
if FlankeSekpuls = ON then goto weiter2 ' Flanke ein? Bei JA, Sekpuls bereits erfolgt
FlankeSekpuls = ON : Sekpuls = ON ' (Flanke und Sekpuls alle 2,56 sec setzen)
#weiter2
(7) Lösung für größere Zeiten für
Lösung 6 (max 21 Minuten) (define)
Der Zeitimpuls (Bit Sekpuls) ist nicht synchronisiert zum eigenen Programm.
Statt wert1 = TIMER
wird
wert12 = TIMER '(wert12 ist ein word bestehend aus Bytes wert1 und wert2)
Mit wert1 wird weiter gearbeitet, d.h. maskiert wird
das vordere Byte für die Bit-Abfrage.
wert1Bit0 hat den Wert 1 x 256 x 40 msec = 10,24 Sec und verdoppelt sich je Bit bis
wert1Bit7 hat den Wert 128 x 256 x 40 msec = 21,845 Minuten
(8) Lösung mit Timer-Maskierung
und Flanke (max 21 Minuten) (define)
Beispiel: Bit 7
(Wert = 128) ist im Abstand von 5,12 sec (= 128 x 40 msec) eingeschaltet.
Sekpuls = OFF
if (TIMER SHR 7 and 1) = 1 then goto
weiter1 '
BIT 7 des Timers ein? Bei JA, Impuls setzen
FlankeSekpuls = OFF : goto weiter2 ' (Flanke rücksetzen)
#weiter1
if FlankeSekpuls = ON then goto weiter2 ' Flanke ein? Bei JA, Sekpuls bereits erfolgt
FlankeSekpuls = ON : Sekpuls = ON ' (Flanke und Sekpuls setzen)
#weiter2
Je nach Bit-Auswahl beträgt die Impulsfolge bis 21,8
Minuten (Bit 15).
if (TIMER SHR 15 and 1) = 1 then goto
weiter1 '
BIT 15 des Timers ein?
Es wird nur die Zeit bis zur Wiederholung dieses Bits gemessen. Maßgebend ist nur das höchstwertige Bit. Zwischenwerte sind also nicht machbar. Dafür kann die Differenzmessung mit Neuwert (10) benutzt werden.
(9) Varianten zu Lösung 8 (max 21
Minuten) (define)
In vorhergehender Lösung wird das Abfrage-Bit an die gewünschte Stelle geschoben.
Man kann auch den Bitwert abfragen. Hier die verschiedenen Möglichkeiten für den Bitwert dezimal 128.
Sekpuls = OFF
if (TIMER and 128) >< 0 then goto weiter1 ' BIT 7 (Wert = 128) des
Timers aus? Bei JA, Impuls setzen
FlankeSekpuls = OFF : goto weiter2 ' (Flanke rücksetzen)
#weiter1
if FlankeSekpuls = ON then goto weiter2 ' Flanke ein? Bei JA, Sekpuls bereits erfolgt
FlankeSekpuls = ON : Sekpuls = ON ' (Flanke und Sekpuls setzen)
#weiter2
Hier eine andere
Möglichkeit den Bitwert zu wählen. Die Lücken im Binärformat sind nur zur
besseren Lesbarkeit eingefügt.
if (TIMER and &B 0000 0000 1000 0000) >< 0 then goto weiter1 ' BIT 7 (Wert = 128) des Timers aus?
(10) Lösung mit Timer Neuwert
(Zeit-Differenz max 21 Minuten) oberes Byte (define)
Neuwert belegt hier nur ein Byte statt ein word. Dieser Vorteil hat den Nachteil einer Ungenauigkeit von 5,12 sec.
Dies gilt nur beim ersten Impuls. Die Impulsfolge ist konstant.
In verfahrenstechnischen Anlagen ist die Zeitgenauigkeit nicht wesentlich.
Zeiten von 256 x 20 msec = 5,12 sec bis 255 x 256 = 21 Minuten sind möglich.
Ohne Uhr kann man mit dieser Methode Minuten-Impulse erzeugen für die Wartezeiten in Ablaufsteuerungen (siehe Steuerungstechnik).
Define Zeitmass 12 ' x
256 x 20 msec = 61 Sekunden (Beispiel ca. 1 Minute)
Minpuls = OFF
wert12 = TIMER '(wert12
ist ein word bestehend aus Bytes wert1 und wert2)
if wert1 = Neuwert then goto weiter1 ' (wartet bis Timer den Neuwert erreicht hat)
Flanke = OFF : goto Ende '
(Flanke rücksetzen)
#weiter1
if Flanke = ON then goto Ende ' Flanke ein? Bei JA, Minpuls bereits erfolgt
Flanke = ON : Minpuls = ON ' (Flanke und Minuten-Impuls setzen)
Neuwert = wert1 + Zeitmass ' (Bildung des neuen Werts mit Maskierung byte)
#Ende
(11) Lösung mit Timer Neuwert
(Zeit-Differenz max 10 Minuten) (define)
Braucht man genaue Zeiten muss man für Neuwert ein word nehmen.
Zeiten bis 10 Minuten sind möglich.
Define Zeitmass 10000 '
x 20 msec = 200 Sekunden
Zeitpuls = OFF
Der Timer muss maskiert
werden. Bei der folgenden Maskierung sind die Bits Wert 63 auf Null gesetzt,
damit 63 x 20 msec für die zeitliche Abfrage auf „gleich“ zur Verfügung stehen.
Bei längerer Zykluszeit des gesamten Programms kann auch mit &HFF80 für 127
x 20 msec maskiert werden.
if Neuwert =
TIMER and &HFF80' then goto weiter1 '
(wartet bis Timer den Neuwert erreicht hat)
Flanke = OFF : goto Ende '
(Flanke rücksetzen)
#weiter1
if Flanke = ON then goto Ende ' Flanke ein? Bei JA, Minpuls bereits erfolgt
Flanke = ON : Zeitpuls = ON ' (Flanke und Zeit-Impuls setzen)
Neuwert = Timer + Zeitmass ' (Bildung des neuen Werts word)
#Ende
(12) Lösung mit Timer-Byte und Wartezeit-Bit
(Zeit-Differenz max 21 Minuten)
Je nach Maskierung wird der mögliche
Zeitbereich bzw. der Zeitfaktor festgelegt.
Define wert3 byte
' wert3 = Timer Zeitfaktor 20 msec max. Zeit 5 sec
' wert3 = Timer SHR
8 Zeitfaktor 256*20 msec 5 sec bis 21 Minuten
' wert3 = Timer SHR
7 Zeitfaktor 128*20 msec 2,5 sec bis 10 Minuten
' wert3 = Timer SHR 6 Zeitfaktor
64*20 msec 1,3 sec bis 5 Minuten
wert3 = Timer '
alternativ wählen z.B. wert3 = Timer SHR 8
if WartezeitBit = OFF then goto Schrittregister
if Neuwert < wert3 then goto ENDE '= warten auf
Timer-Überlauf
if wert3 > Neuwert then WartezeitBit = OFF ' = Zeit abgelaufen
goto Ende
' Schrittregister
if
(Schritt = 2) then goto Schritt2 '
if (Schritt = 3) then goto Schritt3 '
goto Ende
#Schritt2 ' Setzen der
Wartezeit bis Schritt 3 bearbeitet wird
K2 = ON
' Zeitfaktor je nach gewählter Maskierung z.B. *20 msec
' Wartezeit beträgt 150 * 20 msec = 3 sec
Wartezeit = 150 ' bis ca. 200 zulässig (wegen Byte)
Goto TimerNeuwert
#TimerNeuwert
WartezeitBit
= ON
Neuwert = wert3
+ Wartezeit ' Bilden des Neuwerts (byte)
#Schrittweiter
'
Schritt = Schritt + 1
#Ende '
(13) Lösung mit Timer Neuwert
(Zeit-Differenz max 10 Minuten) (define)
Neuwert statt Altwert hat den Vorteil, dass in mehreren Schritten verschiedenen Wartezeiten gesetzt werden können.
Beispiel mit Schrittregister (siehe auch Kapitel Steuerungstechnik).
Zur Messung wird der freilaufende 20 ms – Timer benutzt.
Der Vorteil gegenüber
Minuten-Impulsen besteht darin, dass die Zeit feinstufig ist, z.B. wenn
sie variabel aus einer Berechnung stammt.
Abfrage Neuwert
erreicht
if (Neuwert – TIMER)
> 0 then goto Ende 'Wartezeit läuft? Ja,
dann warte
' Schrittregister
if
(Schritt = 2) then goto Schritt2 '
if (Schritt = 3) then goto Schritt3 '
goto Ende
#Schritt2 ' Setzen der
Wartezeit bis Schritt 3 bearbeitet wird
K2 = ON '
Wartezeit = 50 'x 20 MilliSekunden = 1 Sekunde
Goto TimerNeuwert
#TimerNeuwert
Neuwert =
TIMER + Wartezeit ' Bilden des Neuwerts
(word)
#Schrittweiter
'
Schritt = Schritt + 1
#Ende '
Die Wartezeit ist nur bis zur Bildung des Neuwerts notwendig.
Zur Einsparung von Variablen kann die Wartezeit auch Neuwert genannt werden oder das gleiche byte bzw. word belegen.
Zulässig ist maximal: Wartezeit = 32767 'x 20 msec = 10,92.. Minuten
Erläuterung zum Timerüberlauf (siehe auch Tipps):
Neuwert = Timer + Wartezeit (32767 + 32767 = 65534 das sind – 2)
If Neuwert – Timer > 0 ? Ja (- 2 – 32767 = -32769 das sind +2)
(14)
Lösung mit Timer Neuwert (Zeit-Differenz max 21 Minuten) (define)
Der Timer läuft von –32768 bis + 32767. Das sind 65535 Zeitabschnitte je 20 msec.
Achtung. Unzulässig ist das folgende Verfahren:
Wartezeit = 30000 'x 20 MilliSekunden = 10 Minuten
Wartezeit = Wartezeit
+ 30000 '10 + 10
= 20 Minuten
Die Bedingung if (Neuwert – TIMER) > 0 ist am Anfang nicht erfüllt (negativer Gesamtwert).
Lösung:
Wenn man den
Timerwert um 1 Bit nach rechts schiebt,
dann arbeitet man mit 0 bis 32767, also immer im positiven Bereich und mit 40
msec.
Abfrage Neuwert erreicht
if Neuwert - (TIMER SHR 1 AND &H7FFF) > 0
then goto Ende 'Wartezeit läuft? Ja, dann
warte
' Schrittregister
if
(Schritt = 2) then goto Schritt2 '
if (Schritt = 3) then goto Schritt3 '
goto Ende
#Schritt2 ' Setzen der
Wartezeit, danach wird Schritt 3 bearbeitet
K2 = ON '
Wartezeit = 30000 'x 40 msec = 20 Minuten
Goto TimerNeuwert
#TimerNeuwert
Neuwert =
((TIMER + Wartezeit) SHR 1) and &H7FFF '
Bilden des Neuwerts
#Schrittweiter
'
Schritt = Schritt + 1
#Ende '
Die Maskierung and &H7FFF ist als Fehlerkorrektur für SHR
notwendig, damit das Minus-Bit entfernt wird.
(15)
Lösung mit Timer Neuwert (Zeit beliebig)
(define)
Beliebige Addition von Wartezeiten durch mehrere Wartezeitschritte.
if (Neuwert – TIMER) > 0 then goto Ende 'Wartezeit läuft? Ja, dann warte
' Schrittregister
if (Schritt = 1) then goto Schritt1 ' z.B K2 = ON
if (Schritt = 2) then
goto SchrittWartezeit10min ' 10 Minuten
if
(Schritt = 3) then goto SchrittWartezeit10min '
Nochmals 10 Minuten
if (Schritt = 4) then goto SchrittWartezeit30sec ' zusätzlich 30 sec
if (Schritt =
5) then goto Schritt5 ' z.B K2 = OFF
goto Ende
#SchrittWartezeit10min '
Setzen der Wartezeit
Wartezeit = 30000 'x 20 MilliSekunden = 10 Minuten
Goto TimerNeuwert
#SchrittWartezeit30sec '
Setzen der Wartezeit
Wartezeit = 1500 'x 20 MilliSekunden = 30 Sekunden
Goto TimerNeuwert
#TimerNeuwert
Neuwert =
TIMER + Wartezeit ' Bilden des Neuwerts
#Schrittweiter
'
Schritt = Schritt + 1
#Ende
(16)
Lösung mit aktueller Uhrzeit (Zeit beliebig)
(define)
Beliebige Wartezeiten können auch mit
Schaltuhr erreicht werden. Siehe Softwarebausteine.
-------------------------------------
ENDE Tipps Teil 3 ------------ nach_oben
weiter zu Tipps Teil 4 zurück zu Tipps_Teil_1 Startseite
