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_links_und_rechts Ziffern vereinzeln
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
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).
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
(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.
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
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
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
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
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“
(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.
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
