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

nach_oben

(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

nach_oben

(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

nach_oben

(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.

nach_oben

(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?

nach_oben

(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

nach_oben

(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)

nach_oben

(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.

nach_oben

(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 

 

Kostenlose Zähler und Statistiken für Ihre Website bei www.motigo.com