2. Tipps und Tricks  Teil 1  (Stand: 29.2.2008)

Bedienungsanleitung und Befehlsliste können beim Programmieren am PC mit Taste F1 aufgerufen werden.

Zahlen_und_Zeichenformate  Binär, Hexadezimal, BCD, Dezimal, ASCII

Überlauf 32767 und Übergang -1 nach 0 zum Verständnis des Timers

Maskierung_im_Byte

Maskierung_links_und_rechts  Ziffern vereinzeln

Maskierung_im_Word

Word_Byte_Bit_Handling     

Rechnen_Rangfolge_mit_Klammer und Maskierung

Zahlenausgabe_mit_Komma  Handhabung des Modulobefehls    NEU

Aufrunden von Zahlen

Weiter zu Tipps_und_Tricks_Teil_2  

Inhaltsverzeichnis

Sparen von Variablen,  Pseudo-Variable  (mehr als 24 Variable siehe Stolpersteine),

Zähler 9 Bit, bzw. Erweiterung Zähler-Byte mit Bits (Wert 0 bis 511 bzw. 1023) 

Beispiele: Istwerte und Sollwerte, temporäre Variable, gepackte Variable, Mittelwertbildung, Messwertberuhigung

Byte, Word und Bit als Zwischenspeicher,

Negative Zahl im Byteformat (Minus-Temperatur)

Messung der Zykluszeit eines Programmdurchlaufs, Einsparen von  Zykluszeit, Bedienungstakt

5 statt 4 GOSUB

Störungsverlauf bereits vor Eintritt der Störung speichern (Fehleranalyse) 

     Teil 2 Fortsetzung  Uhr   Inhaltsverzeichnis   (Stand: 25.9.2008)

Sytem-Uhr und Funk-Uhr (Ausfallmeldung)

Ausgabe Dow-Text  Mo Di Mi Do Fr Sa So  Zugriff auf Tabelle

Letzter Tag im Monat , Sommerzeit_bestimmen  als Remanentes Merker-Bit  

Teil 2 Fortsetzung   Datum_berechnen Inhaltsverzeichnis (Stand: 11.2.2009)

Tagnummer im Jahr, DOW Tagnummer in der Woche, Wochen-Nummer im Jahr

Osterdatum und Rosenmontag, Karfreitag, Himmelfahrt, Pfingsten  NEU überarbeitet

 Datum von Buß- und Bettag, Muttertag, Sommerzeit, Advent berechnen

 Steuern mit Feiertagsbit für Heizung und Rollladen

Weiter zu Tipps und Tricks Teil 3

Zeittakte mit Uhrzeit und TIMER, Wartezeit,

(Schaltuhr siehe Softwarebausteine)

Weiter zu Tipps und Tricks Teil  4

Ü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 


Phantasie ist wichtiger als Wissen.  (Albert Einstein)

2.1.0)  Zahlen- und Zeichenformate (Grundlagen)

Im Kapitel „Softwarebausteine“ kann ein Programm geladen werden, welches die Dezimalzahl auf  HEX-Zahl umrechnet und zusammen mit dem ASCII-Zeichen auf dem LCD-Display anzeigt.

Binärsystem

Eigentlich gibt es im Computer nur die Zahl 0 und 1 (Aus und Ein). Der Übergang zur 2-stelligen Zahl  findet in dem Binärsystem bereits bei der nächsten Binär-Zahl 10 statt. Im Dezimalsystem ist der Übergang erst bei der 9 zur 2-stelligen 10.

Auch im Binärsystem heißt diese Zahl 10; man sagt aber „Eins Null“ und sie hat den Dezimalwert 2.

Hexadezimal

ist nur eine verkürzte Schreibweise der Binärzahl eines Vierer-Blocks der Binärzahl 0000 bis 1111 als 0 bis F. Den einstelligen Wert 0 bis F der Hexzahl nennt man Nibble.

BCD-Code (Binär codierte Dezimalzahl) ist eine auf  0 bis 9 eingeschränkte Hexadezimalzahl.  Die Hex-Werte A bis F  für dezimal 10 bis 15 entfallen

ASCII – Code (American Standard Code for Information Interchange)

enthält Buchstaben, Zahlen und Steuerzeichen, z.B. HEX 31 ist die Zahl 1, HEX 41 ist der Buchstabe A, HEX 61 ist der Buchstabe a.

Alle ASCII-Zeichen siehe Link-Liste.

In der C-Control gibt es die folgenden drei Zahlensysteme:

Binär                          Dezimalwert     HEX-Wert

&B 0000 0000                       0          &H 00

&B 0000 0001                       1          &H 01

&B 0000 0010                       2          &H 02

&B 0000 0011                       3          &H 03

&B 0000 0100                       4          &H 04

&B 0000 0101                       5          &H 05

&B 0000 0110                       6          &H 06

&B 0000 0111                       7          &H 07

&B 0000 1000                       8          &H 08

&B 0000 1001                       9          &H 09

&B 0000 1010                       10        &H 0A

&B 0000 1011                       11        &H 0B

&B 0000 1100                       12        &H 0C

&B 0000 1101                       13        &H 0D

&B 0000 1110                       14        &H 0E

&B 0000 1111                       15        &H 0F

 

&B 0001 0000                       16        &H 10

nach_oben

Umrechnung von Binär in Dezimal

Bei der Dezimalzahl heißen die Ziffern von rechts nach links Einer, Zehner, Hunderter, usw.

Bei der Binärzahl werden die Ziffern von rechts nach links mit ihren Hochzahlen benannt.

64 32 16   8  4  2  1                Dezimalwert

 7  6  5  4  3  2  1  0                Hochzahl

&B     0  0  0  0  1  0  0  0                2*2*2 =  8   (Hochzahl = Anzahl Faktoren)

&B     0  0  0  0  1  0  1  1                8 +2 +1= 11 (Summe der Dezimalwerte)

2´`4 (sprich 2 hoch 4) bedeutet 2*2*2*2  also = 16

2´`3 (sprich 2 hoch 3) bedeutet 2*2*2  also = 8

2´`2 (sprich 2 hoch 2) bedeutet 2*2  also = 4

2´`1 (sprich 2 hoch 1) ist  = 2

2´`0 (sprich 2 hoch 0) ist = 1 

Nach links verdoppelt sich jeweils der Wert. Darstellung word (16 Bit)

    (16    15     14     13     12    11     10   9     8    7   6    5   4  3  2  1   Bit-Nr.)

      - 16384 8192 4096 2048 1024 512 256 128 64 32  16  8  4  2  1  Dezimalwert

     VZ   14     13     12     11    10     9     8     7    6    5   4   3  2  1  0  Hochzahl

&B  0      0      0       0       0      0      0     1     0    0   0   0   0  0  0  0  = 2´`8 = 256

Im Folgenden wird nicht die Bit-Nr. verwendet sondern die Hochzahl wird Bit genannt.

Dadurch lässt sich der Wert von Bit 8 leicht berechnen mit 2 hoch 8 = 256.

2.1.1) Überlauf bei Addition (Subtraktion sinngemäß)

Zum Verständnis des Timers sind hier zwei Übergänge dargestellt:
Überlauf von 32767 auf  - 32768
0111 1111 1111 1111  ist die Zahl 32767
+ 1
1000 0000 0000 0000  ergibt die Zahl -32768 bei integer 16 Bit
+ 1
1000 0000 0000 0001  ergibt die Zahl -32767 bei integer 16 Bit

Übergang von –2 auf   –1  auf  Null  auf  +1

1111 1111 1111 1110  ist die Zahl  –2
+ 1
1111 1111 1111 1111  ergibt die Zahl  –1
+ 1
0000 0000 0000 0000  ergibt die Zahl Null

+ 1
0000 0000 0000 0001  ergibt die Zahl +1

Für Subtraktion geht man die Zeilen von unten nach oben durch (entspricht -1 statt +1).

nach_oben

2.1.2) Maskierung   im Byte

Beispiel: In einem Byte stehen 2 Zählerstände jeweils von  0 bis 15.

Binär                          Dezimalwert     HEX-Wert

&B 0110 1001             105                &H 69

Man erkennt sofort, dass die beste Darstellung das HEX-Format ist.

Im Folgenden werden mehrere Verfahren gezeigt die Zählerstände zu vereinzeln bzw. zu bearbeiten. 

(1)   Lösung mit Division und MOD-Befehl

Das linke Nibble beginnt mit Bit 4 (Wert =16).

Binär                          Dezimalwert     HEX-Wert

&B 0110 1001             105                &H 69

Zählerstande vereinzeln

wert1 = Zaehler / 16  bedeutet 105 / 16 = 6 (Kommastellen werden abgeschnitten)

Binär                          Dezimalwert     HEX-Wert

&B 0110 1001             105                &H 69  Zähler

----------------  / 16 -----------------------------------------------

&B 0000 0110                 6                &H 06 

 

wert2 = Zaehler  MOD 16  Ergebnis = 9 , weil 105 / 16 = 6 Rest 9 ist.

Binär                          Dezimalwert     HEX-Wert

&B 0110 1001             105                &H 69  Zähler

----------------  MOD 16 -----------------------------------------------

&B 0000 1001                 9                &H 09

Zählerstände bearbeiten

Rechten Zähler + 1 erhöhen: Zaehler = Zaehler + 1

                       oder     Zaehler = Zaehler +  &H 01

Linken Zähler + 1 erhöhen: Zaehler = Zaehler + 16

                       oder     Zaehler = Zaehler +  &H 10

 

  nach_oben

(2)   Lösung mit AND-Befehl (Maske)

Ergebnis = Zaehler AND &H 0F

Binär                          Dezimalwert     HEX-Wert

&B 0110 1001             105                &H 69  Zähler

&B 0000 1111                                   &H 0F  Maske

----------------  AND -----------------------------------------------

&B 0000 1001                 9                &H 09  Ergebnis

(3)   Lösung mit Schiebeoperation  SHR

Ergebnis = Zaehler  SHR 4

Binär                          Dezimalwert     HEX-Wert

&B 0110 1001             105                &H 69  Zähler

----------------  SHR -----------------------------------------------

&B 0000 0110                 6                &H 06  Ergebnis

(4)   Lösung mit Byte-Maskierung und Schiebeoperation  SHL und  SHR

Define  AnzeigeNr  byte [1] '

Define  X4     Bit [5]

Define  X5     Bit [6]

Define  X6     Bit [7]

Define  X7     Bit [8]

AnzeigeNr = AnzeigeNr SHL 4 ' Maskierung wirkt als Reset Bit X4,5,6,7

AnzeigeNr = AnzeigeNr SHR 4 ' Im Byte steht nun AnzeigeNr allein

Diese Maskierung  arbeitet bei  SHL 4 nur bei Byte-Maskierung.

Die folgende Schiebe-Operation ohne Byte-Maskierung arbeitet fehlerhaft.

AnzeigeNr = AnzeigeNr SHL 12  SHR 12 ' Achtung Fehlermöglichkeit! (siehe Stolpersteine)

Fehler-Korrektur mit Maskierung

AnzeigeNr = AnzeigeNr SHL 12  SHR 12 AND &H000F

Natürlich reicht in diesem Fall die Maskierung allein. 

nach_oben

2.1.3) Maskierung links und rechts (Ziffern vereinzeln)

Zaehler = 234

1. Ziffer: wert1 = Zaehler  / 100                      234 / 100 = 2

2. Ziffer: wert1 = Zaehler  MOD 100 / 10      234 MOD 100 = 34   34 / 10 = 3

3. Ziffer: wert1 = Zaehler  MOD 10               234 MOD 10 = 4

 

2.1.4)  Maskierung  im Word

Sinngemäß können die Maskierungen wie bei Byte durchgeführt werden z.B.

(1)   Lösung mit Division und MOD-Befehl

Zerlegen von word in bytes

Diese Zerlegung kann nicht angewendet werden, wenn word negativ ist.

Das linke Byte darf also nur bis 127 enthalten bzw. Word max 32767.

wert1 = Word / 256               wert1 enthält linkes Byte

wert2 = Word  MOD 256      wert2 enthält rechtes Byte

Zusammensetzen von Bytes zu Word

wert1 = x

wert2 = y

Word hat den Inhalt  256*x  +  y

oder direkt berechnet Word = 256 * wert1  +  wert2

 

(2)   Lösung mit Maskierung und Schiebefunktion

Beispiel Schieberegister für zwei Zählerstände im word:

Rechtes Byte

Ergebnis = Zaehler  AND 255 ' Dezimal 255 = &H00FF

Üblicherweise wird mit HEX-Werten maskiert:

Ergebnis = Zaehler  AND &H00FF

Linkes Byte

Bei der Schiebefunktion SHR wird das Bit 15 (Minuszeichen) mitgenommen.

Es werden also nicht immer Nullen nach geschoben, sondern bei Minus folgen Einsen.

Dies wird korrigiert, indem zusätzlich maskiert wird.

Ergebnis = Zaehler  SHR 8 AND &H00FF

Binär                                      Byte links rechts           HEX-Wert

&B 10000000 01111111         128 ; 127                  &H 807F  Zähler

----------------  SHR 8 -----------------------------------------------

&B 11111111 10000000          255 ; 128                 &H FF80  (Fehler)

&B 00000000 11111111              0 ; 255                 &H 00FF  Maske

----------------  AND -----------------------------------------------

&B 00000000 10000000              0 ; 128                 &H 0080  Ergebnis

 

(3)  Lösung durch Überlappung Word mit Bytes

define SpeicherZahl     word[1]

define Wert12             word[2] ' = Byte 3,4 (Word-Zwischenspeicher)

define Wert1               byte [3]  ' Byte 3 Zwischenspeicher 1

define Wert2               byte [4]  ' Byte 4 Zwischenspeicher 2

Word Wert12 benutzt denselben Bereich wie die Bytes Wert1 und Wert2

Wert12 = SpeicherZahl  ' wird in Word-Zwischenspeicher geladen.

Durch diese einfache Methode stehen nun Bytes Wert1 und Wert2 also linkes und rechtes Byte zur Verfügung.

Andererseits kann durch Setzen der Bytes wert1 und wert2  das word wert12 geladen werden. 

Wert1 = 37 :  wert2 = 154

Im  word  wert12 steht nun das Ergebnis von 37 * 256 + 154

nach_oben

2.1.5) Word-, Byte- und Bit-Handling

define Wert1 byte [3]  ' Byte 3 Zwischenspeicher 1

define Wert2 byte [4]  ' Byte 4 Zwischenspeicher 2

define Wert12 word[2] ' = Byte 3,4 (Überlappung mit Bytes Wert1 und Wert2)

define wert1Bit0 Bit [17] ' für bit-Handling des byte Wert1 (Zwischenspeicher)

define wert1Bit1 Bit [18]

define wert1Bit2 Bit [19]

define wert1Bit3 Bit [20]

define wert1Bit4 Bit [21]

define wert1Bit5 Bit [22]

define wert1Bit6 Bit [23]

define wert1Bit7 Bit [24]

(1) Durch Setzen und Rücksetzen der Bits werden das Byte wert1 und das word wert12 verändert.

Wert12 = 0         ' Byte 3 und 4, word 2 und alle Bits werden Null gesetzt

Wert1Bit2 = ON ' bewirkt wert1 = 4 und wert12 = 1024.

(2) Abfrage von einzelnen Bits von Zahlen mit Hilfe von wert1.

Die Bits von Wert2 sollen abgefragt werden (oder &B 0000 1001 oder &H 0B):

wert1 = wert2 ' Byte wird nach wert1 geladen

If  wert1Bit3 = ON then ....

Anwendung siehe auch 2.4 und 2.5 unter Tipps Teil 2

(3) Abfrage mit Division und Modulo

Ergebnis 0 entspricht OFF und 1 entspricht ON (nicht –1, denn hier wird Bitwert gebildet, siehe Stolpersteine)

Abfrage Bit 0

Bitwert = Wert MOD 2  (Ergebnis ist Wert 0 bzw. 1)

Abfrage Bit 1

Man teilt durch 2 (oder durch &B 0000 0010   <- Bit 1 gesetzt)

Anschließend wird mit Modulo-Division festgestellt, ob ein Rest (=1, also ON) bleibt.

Bitwert = Wert / 2 MOD 2

oder alternativ schiebt man nach rechts um ein Bit

Bitwert = Wert SHR 1 MOD 2

Abfrage Bit 2

Man teilt durch 4 (oder durch &B 0000 0100  <- Bit 2 gesetzt)

Bitwert = Wert / &B 0000 0100 MOD 2

oder schiebt nach rechts um zwei Bit

Bitwert = Wert SHR 2 MOD 2

Wegen der besseren Übersichtlichkeit ist die Bit-Darstellung oder der Befehl SHR sinnvoll.

Möchte man Bit 2 abfragen (maskieren) gilt SHR 2 und bei Bit 3 natürlich SHR 3, usw.

bzw. &B 0000 0100 für Bit 2 und bei Bit 3 gilt &B 0000 1000

define     nach_oben

2.1.6) Rechnen mit Klammern und Rechenfolge

In der Anleitung zur C-Control (siehe Linkliste) steht eine Tabelle für die Rangfolge von Operationen.

(1) Die wichtigste Regel ist die Punkt-vor-Strich-Regel.

Punkt bedeutet Multiplikation sowie Division. Strich bedeutet Addition und Subtraktion.

Es wird also erst multipliziert bzw. dividiert und danach addiert bzw. subtrahiert.

Möchte man eine andere Reihenfolge, setzt man Klammern.

Im folgenden Beispiel wird wegen der Klammern erst im Nenner addiert (Strichrechnung) und danach Zähler durch Nenner dividiert (Punktrechnung).

Nutzungsgrad = 100* Eindauer / (Eindauer + Pausendauer)

(2) Rangfolge der Befehle

Neben der Rangfolge laut Tabelle in der Dokumentation gilt bei gleichem Rang:

Die gleichrangigen Befehle  werden von links nach rechts abgearbeitet.

Aufgabe: Aus der Variablen VB soll das linke mittlere Nibble (die Drei) auf das rechte Nibble von VA gesetzt werden, dabei dürfen die anderen Nibble nicht geändert werden.

VariableA    VA = &HABCD

VariableB     VB = &H4321

1.) VA = VA and &HFFF0 '  rechtes Nibble VA wird Null gesetzt mit Maske FFF0

VB and &H0F00 '  Nibble von VB wird maskiert (0300 ausgefiltert mit Maske 0F00)

(VB and &H0F00) SHR 8  ' Nibble wird nach rechts geschoben 0003

 „Schieben“ hat einen höheren Rang als „and“. Mit der Klammer wird erzwungen, dass erst VB mit der Maske bearbeitet wird.

Ohne Klammer würde das F in der Zahl &H0F00 geschoben.

2) VA = (VB and &H0F00) SHR 8 or VA ' VA und VB wird zusammengefügt ABC3

alternative Lösungen:

Erst Schieben und dann rechtes Nibble maskieren.

Gleichrangige Befehle werden links beginnend abgearbeitet, also erst „and“ danach „or“.

VA = VB SHR 8 and &H000F or VA ' VA und VB wird zusammengefügt ABC3

In der folgenden Zeile würde „or“ vor „and“  ausgeführt.

VA = VA or VB SHR 8 and &H000F ' falsch: zuletzt wird maskiert. Fehler: 0003 statt ABC3

Mit Klammer kann jedoch das richtige Ergebnis erzwungen werden.

VA = VA or (VB SHR 8 and &H000F) ' richtig: erst wird maskiert, dann mit „or“ entsteht ABC3

nach_oben

2.1.7) Zahlenausgabe mit Komma

(1)   Positive Zahlen mit Kommastelle Zehner-System

Beispiel: Es soll ein Temperaturwert (37,4) mit einer Kommastelle ausgegeben werden.

Der Wert (374) liegt in Zehntelgrad im word Temp.

Vorkomma:      Wert1 = Temp / 10                 ' Ergebnis 37

Kommastelle:   Wert2 = Temp  MOD 10        ' Ergebnis 4

Nach der Modulo-Division mit 10 ist der Rest die 1-stellige Kommastelle.

 

Der Wert (3745) liegt in  Hundertstelgrad vor:

Vorkomma:      Wert1 = Temp / 100               ' Ergebnis 37

Kommastellen: Wert2 = Temp  MOD 100      ' Ergebnis 45

Nach der Modulo-Division mit 100 ist der Rest die 2-stellige Kommastelle.

Achtung, die führende Null muss ausgegeben werden, sonst wird aus 09 eine 9 hinter dem Komma (hierzu siehe Softwarebausteine).

Möchte man jedoch nur 1-stellig anzeigen, wird nach der Modulo-Division noch durch 10 geteilt:

Kommastelle:   Wert2 = Temp  MOD 100   / 10   'Rest  45 / 10 Ergebnis 4

oder erst durch 10 teilen und dann MOD 10

Kommastelle:   Wert2 = Temp  / 10  MOD 10   ' 374 MOD 10 Ergebnis 4

(2)   Positive und negative Zahlen mit Kommastelle

Beispiel: Es soll ein Temperaturwert (-17,4) mit einer Kommastelle ausgegeben werden.

Der Wert (-174) liegt in Zehntelgrad im word Temp.

Ausgabe auf LCD

if  Temp < 0 then gosub Minus else gosub space  ' Minus bzw. Leerzeichen ausgeben

  ' Durch den Befehl abs (absolut) wird negative Zahl zur positiven Zahl umgeformt.

Vorkomma:      wert1 = abs (Temp) / 10

Kommastelle:   wert2  =  abs (Temp) MOD 10

Ausgabe mit Terminalprogramm (PC)

Ohne Kommastelle genügt print Temp , um eine positive Zahl ohne Vorzeichen und eine negative Zahl mit Minus auszugeben.

Mit Kommastelle muss wegen –0,1 bis – 0,9 das folgende Verfahren angewendet werden. Space kann auch weggelassen werden oder anstelle von space kann auch + gesetzt werden. Ebenfalls eignet sich das Verfahren, um Zahlen ohne Kommastelle mit + und - anzeigen zu lassen.

if  Temp < 0 then print  “-“ else  print “ “;  ' Minus bzw. Leerzeichen ausgeben

print  abs (Temp)  / 10; “,“;  abs (Temp) MOD 10

Weiteres Ausgabeprogramm siehe Kapitel „Softwarebausteine Teil 3 Applikationsboard“

Negative Zahl in einem Byte siehe Kapitel „Tipps und Tricks Teil 2“

nach_oben

(3)   Bewertung des Modulo-Wertes (halbe Grade)

Beispiel: Es soll ein Temperaturwert (37,5) mit einer Kommastelle ausgegeben werden.

Der Wert (75) liegt in Halbgraden im word Temp.

Vorkomma:      Wert1 = Temp / 2                   ' Ergebnis 37

 = Temp  MOD 2        ' (Ergebnis 1)

Kommastelle:   Wert2 = Temp  MOD 2 * 5    ' Ergebnis 5

Das Ergebnis der Modulo-Division muss bewertet werden. Eine (1) ist ein halbes Grad (,5).

(4)   Bewertung des Modulo-Wertes bei festem Nenner

Beispiel: Die Durchschnittstemperatur soll  mit  Kommastelle ausgegeben werden.

11 Messwerte (0 bis 99) bildeten den Wert (83)  im word Temp.

Vorkomma:      Wert1 = Temp / 11                 ' Ergebnis 7

 = Temp  MOD 11      ' (Ergebnis 6)

Kommastelle:   Wert2 = Temp  MOD 11 * 10 / 11     ' Ergebnis 5

Das Ergebnis der Modulo-Division muss bewertet werden mit 10/11.

Möchte man 2-stellig ausgeben, ist der Rest entsprechend zu bewerten.

Kommastellen: Wert2 = Temp  MOD 11 * 100 / 11   ' Ergebnis 54

Allgemein ausgedrückt für beliebige Nenner:

Komma 1-stellig: Wert2 = Temp  MOD Nennerwert * 10 / Nennerwert

Komma 2-stellig: Wert2 = Temp  MOD Nennerwert * 100 / Nennerwert

Nach der Modulo-Division kann der Rest maximal Nennerwert minus 1 betragen.

Achtung! Die Multiplikation z.B. (Nennerwert –1) * 100 darf 32767 nicht überschreiten.

Eine Gegenmaßnahme ist im folgenden Abschnitt (4) beschrieben.

(5)    Variabler Nenner

Beispiele: Es soll der Nutzungsgrad als %-Zahl mit einer Kommastelle ermittelt werden.

Nutzungsgrad = 100* Eindauer / (Eindauer + Pausendauer)

Rest                = 100* Eindauer MOD  (Eindauer + Pausendauer)

Schalthäufigkeit je Stunde ab 00:00 Uhr minutengenau:

Schalthäufigkeit = Zähler * 60 / ( HOUR * 60 + MINUTE)

Rest                = Zähler * 60 MOD ( HOUR * 60 + MINUTE)

Der Rest nach der Modulo-Division  ist die Grundlage zur Berechnung der Kommastelle wie vor beschrieben.

Hier ist besonders darauf zu achten, welche Werte Eindauer und Pausendauer bzw. die Zeit erreichen können.

Die Zeit kann maximal 23*60 + 59 = 1439 Minuten betragen, d.h. der Rest nach  MOD 1439 wird maximal 1438.

Rest                = Zähler * 60 MOD (1439) ' (Ergebnis max 1438)

Komma 1-stellig: Wert2 = Zähler * 60  MOD (1439) * 10 / (1439) ' Ergebnis 1438*10/1439 = 9 (integer)

Bei 2-stellig würde die Zahl 1439 * 100  größer 32767.

Die 2-stellige Ausgabe wäre bei diesem Beispiel nur bis 327 Minuten  möglich.

Das folgende Beispiel zeigt den Fehler und die Gegenmaßnahme

Komma 2-stellig: Wert2 = Zähler * 60  MOD (1439) * 100 / (1439) ' Fehler !

Komma 2-stellig: Wert2 = Zähler * 60  MOD (1439) * 20 / (1439) *5 ' Ergebnis 1438*20/1439 *5= 99 (integer)

Die notwendige Multiplikation mit Faktor 100 wird unterteilt in Faktoren 20 und 5.

Rechnen mit Zahlen über 32767 siehe Teil 4.

nach_oben

2.1.8) Aufrunden von Zahlen

x = 26 / 3 beträgt 8,66.

Da C-Control nur mit ganzen Zahlen (Integer) rechnet, lautet das Ergebnis abgerundet x = 8.

Möchte man 8,66 auf 9 aufrunden, kann man folgende Routine anwenden. Dabei wird ab 5 aufgerundet.

Weil 260 durch 3 geteilt wird, ist die Kommastelle vorübergehend nach rechts verschoben.

x = ( 10*26/3 +5 ) /10 (Ergebnis = 9)

Möglich ist auch den halben Nenner hinzu zu addieren. Dieses Verfahren muss eingesetzt werden, wenn die Zahl  mit 10 multipliziert größer 32767 wird:

x = (26 + 3/2) / 3 (Ergebnis = 9)

Der halbe Nenner beträgt 3/2 = 1,5 als Integer also 1.

 

 

--------------------  ENDE    Tipps und Tricks  Teil 1 ------------  nach_oben

-----------------   weiter zu  Tipps_und_Tricks_Teil_2                       Startseite     

 

 

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