 |
Das deutsche QBasic- und FreeBASIC-Forum
Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
|
| Vorheriges Thema anzeigen :: Nächstes Thema anzeigen |
| Autor |
Nachricht |
tri_s
Anmeldungsdatum: 29.05.2005
Beiträge: 3
|
 Verfasst am: 29.05.2005, 19:46 Titel: Interface programmieren |
 |
|
Hallo allersamt,
ich suche irgendwie eine Anleitung mit den Befehlen in QBasis um ein Interface zu programmieren.
Ich habe ein Interface mit 6 LED und will die jetzt zum laufen bringen.
SO bisschen was weiß ich nocht, wie erster:
OUT 888, 1
So und weiter weiß ich nicht, wie bringe ich mehre LED bis auf die 1 (Pin1) zumlaufen? muss das dann:
OUT 888, 1+2+4+8+16+32 heißen um alle zum Leuchten zubringen? Da verdoppelt man doch alles?! Und wie bringe ich das ganze auf Zeit hin (zb. 30 Sekunden leuchten)??
Danke im voraus
 |
|
| Nach oben |
|
 |
jb
Anmeldungsdatum: 14.01.2005
Beiträge: 2010
|
| Verfasst am: 29.05.2005, 19:58 Titel: |
|
|
Zum LPT-Port: Schau mal ins Profiforum, da gibts schon viele Beiträge dazu.
Zum Thema Wartezeiten: Schau mal in die MonsterFAQ unter TIMER.
Trotzdem hier mal eine einfache Warteschleife über 30s:
| Code: |
t# = TIMER
DO
LOOP UNTIL TIMER > t# + 30
|
jb |
|
| Nach oben |
|
|
MisterD
Anmeldungsdatum: 10.09.2004
Beiträge: 3071
Wohnort: bei Darmstadt
|
| Verfasst am: 30.05.2005, 11:35 Titel: |
|
|
ööhhhmm t#=TIMER ist etwas übertrieben, t!=Timer (single statt double) reicht bei weitem.
_________________
"It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration."
Edsger W. Dijkstra |
|
| Nach oben |
|
|
jb
Anmeldungsdatum: 14.01.2005
Beiträge: 2010
|
| Verfasst am: 30.05.2005, 17:40 Titel: |
|
|
Okay, aber wenn man's halt ultragenau haben will 
Wir haben in der Schule einen Info-Lehrer, der immer DOUBLE benutzt 
jb |
|
| Nach oben |
|
|
noop
Anmeldungsdatum: 04.05.2005
Beiträge: 259
|
| Verfasst am: 30.05.2005, 18:18 Titel: |
|
|
Hallo
Ich hab nichts dazu gefunden.
Was ist denn genau der Unterschied zw. t# und t!?
Und was ist wenn ich nur t schreibe?
Gilt das auch algemein mit # ! ? |
|
| Nach oben |
|
|
jb
Anmeldungsdatum: 14.01.2005
Beiträge: 2010
|
| Verfasst am: 30.05.2005, 18:26 Titel: |
|
|
Also,
# -> DOUBLE
! -> SINGLE
% -> INTEGER
& -> LONG
Wenn du nur t schreibst, setzt QB die Variable automatisch auf SINGLE.
jb |
|
| Nach oben |
|
|
noop
Anmeldungsdatum: 04.05.2005
Beiträge: 259
|
| Verfasst am: 30.05.2005, 18:55 Titel: |
|
|
MMh.
Gut ich weiß jetzt, dass es die vier gibt.
Und nun? Ich hab mal geguckt und was gefunden(Gleitkommazahl, blabla) und eigentlich nichts gecheckt. Und Single hab ich natürlich eine Partnerbörse oda wie man die nennt gefunden |
|
| Nach oben |
|
|
jb
Anmeldungsdatum: 14.01.2005
Beiträge: 2010
|
| Verfasst am: 30.05.2005, 19:56 Titel: |
|
|
Also, für den normalen Gebrauch kannst du dir merken:
INTEGER ist gut für Spiele; ist zwar nicht so genau, aber dafür schnell.
LONG ist für große lange (daher der Name) Zahlen gut.
DOUBLE ist der genaueste Zahlentyp von QB, von dem bei präzisen
Berechnungen Gebrauch gemacht werden kann. Er ist allerdings langsamer.
Alle Klarheiten beseitigt? 
jb |
|
| Nach oben |
|
|
noop
Anmeldungsdatum: 04.05.2005
Beiträge: 259
|
| Verfasst am: 31.05.2005, 19:58 Titel: |
|
|
fast
Wo kann ich SINGLE einordnen?
So als Standard in der Mitte oder als ungenauster, aber auch schnellster?
Was bringt mir das überhaupt? Für Kommazahlen? |
|
| Nach oben |
|
|
Sebastian
Administrator
Anmeldungsdatum: 10.09.2004
Beiträge: 5969
Wohnort: Deutschland
|
| Verfasst am: 31.05.2005, 20:33 Titel: |
|
|
| QBX Hilfe hat Folgendes geschrieben: | | Code: | ------------------------------------------------------------------------------
BASIC Data Types
------------------------------------------------------------------------------
Suffix Data Type Size of Data Range
------ ---------------- ---------------- ---------------------
% INTEGER 2 bytes -32,768 to 32,767
& LONG integer 4 bytes -2,147,483,648 to
2,147,483,647
! SINGLE precision 4 bytes -3.402823E38 to
floating point -1.40129E-45 for
negative values;
1.40129E-45 to
3.402823E38 for
positive values
When compiling with
/Fpa: -3.402823E38
to -1.175494E-38 for
negative values;
1.175494E-38 to
3.402823E38 for
positive values
# DOUBLE precision 8 bytes -1.79769313486231D308
floating point to -4.94065D-324 for
negative values;
4.94065D-324 to
1.79769313486231D308
for positive values
When compiling with
/Fpa:
-1.79769313486231D308
to
-2.2250738585072D-308
for negative values;
2.2250738585072D-308
to
1.79769313486231D308
for positive values.
@ Scaled integer 8 bytes -922337203685477.5808
(CURRENCY) to 922337203685477.5807
$ Variable-length 4 bytes per 0 to 32,767 bytes
STRING descriptor,
1 byte per
string character
$ Fixed-length Number of bytes 0 to 32,767 bytes
string (STRING*num) specified |
|
| QB Mon-FAQ hat Folgendes geschrieben: | *** Datentypen in QBasic
In meinem QBasic-Kochbuch findest Du zu SINGLE und DOUBLE die folgenden Information.
Datentypen werden durch ein nachfolgendes Typendefinitionszeichen im Variablennamen (Suffix) gekennzeichnet.
Eine -> Deklaration der Datentypen und Variablen ist nicht erforderlich, aber mit DIM möglich (siehe unten).
- anna% : INTEGER, Ganzzahl mit Vorzeichen (16 bit)
Wertebereich: -32768...32767
- otto& : LONG, lange Ganzzahl mit Vorzeichen (32 bit)
Wertebereich: -2147483648...2147483647
- egon! : SINGLE, einfach lange Gleitpunktzahl
(32 Bit, 7 Stellen genau)
Wertebereich: +-2,802597 *10^-45...+-3,402823 *10^38
- egon : dito (Suffix "!" ist bei SINGLE-Variablen weglaßbar)
- paul# : DOUBLE, doppelt lange Gleitpunktzahl
(64 Bit, 16 Stellen genau)
+-4,446590812571219 *10^-323...+-1,79769313486231 *10^308
- duda$ : STRING, Text-String (Zeichenkette, max. ca. 32767 Zeichen)
Negative Zahlen werden im Zweierkomplement dargestellt (-1 = FFFFhex).
Textstrings werden im -> ASCII Format dargestellt.
*** erweiterte Datentypen bei PowerBASIC
Bei PowerBASIC gibt es die folgenden zusätzliche Datentypen (die Länge von Strings ist dort nur durch den freien Speicherplatz begrenzt):
- hugo&& : QUAD, vierfach lange Ganzzahl mit Vorzeichen (64 Bit)
- hugo## : EXTENDED, Riesen-Gleitpunktzahl (80 Bit)
- hugo@ : FIX, BCD-Festpunktzahl
- hugo@@ : BCD, BCD-Gleitpunktzahl
- hugo$$ : FLEX Flexibler String (max 32750 Zeichen)
*** explizite Deklaration von Variablen und Datentypen
Datendeklarationen am Programmanfang sind nicht erforderlich, aber nützlich für den automatischen Typ-Check:
*** DIM [SHARED] <Variablenname ohne Suffix> AS <Typ> [,<Variable 2> AS..]
- SHARED ==> auch Subroutinen können die Variable verwenden
(Ohne SHARED sind sie dort unbekannt!). Umgekehrt
kann das Hauptprogramm nur auf Variable einer Sub-
routine zugreifen, die dort mit SHARED deklariert
sind. Bei PowerBasic kann DIM bei Verwendung von
SHARED entfallen.
- <Typ> = INTEGER|LONG|SINGLE|DOUBLE|STRING -(Datentyp, s.o.)
- Beispiele: DIM anna AS LONG, otto AS SINGLE : anna& = 1.234
DIM text AS STRING [*12] - [statischer String mit
der festen Länge von 12 Zeichen]
- Bei der nachfolgenden Verwendung einer mit DIM deklarierten
Variablen kann der Typ-Suffix weggelassen werden
*** Variable, auf die das Hauptprogramm und ein Unterprogramm zugreifen kön-
nen, müssen mit COMMON und SHARED als Globalvariable deklariert werden;
siehe Abschnitt 'Geltungsbereich der Variablen')
Standard-Datentypen für Variable und FUNCTIONen kann man auch am
Programanfang festlegen:
*** {DEFINT|DEFLNG|DEFSNG|DEFDBL|DEFSTR} <Buchstabenliste> : Alle nicht über
einen Datentyp-Suffix (%, &, !, #, or $) definierten Variablen
mit dem Anfangs<Buchstaben> werden auf den Typ INTEGER|LONG|
SINGLE|DOUBLE|STRING gesetzt. Bei der nachfolgenden Verwendung
der Variablen kann der Suffix weggelassen werden. DEFxxx-An-
weisungen müssen in SUBs und FUNCTIONs wiederholt werden;
QBasic fügt dies automatisch ein.
Beispiel: DEFINT A-Z ==> alle Variablen ohne Suffix sind auto-
matisch vom Typ INTEGER (siehe NIBBLES.BAS)
*** Umwandlung von Datentypen ("Typenumwandlung")
Datentypen lassen sich durch "implizite" und "explizite" Typenumwandlungen
ineinander überführen:
*** implizit: Bei einer impliziten Gleitpunkt ==> Integer Wandlung wird
auf die nächstgelegene Ganzahl gerundet; Sonderfall: xxx.5
wird auf die nächste gerade Zahl gerundet. Beispiele:
otto% = 5.5 ==> otto% := 6 (Sonderfall)
otto% = 6.5 ==> otto% := 6 (Sonderfall)
otto% = 2.678 ==> otto% := 3
otto% = 23.42 ==> otto% := 23
anna! = 3.51 : otto% = anna! ==> otto% := 4
*** explizit:
- FIX (<Ausdruck>) - erzeugt den ganzzahligen Anteil d.Ausdrucks
durch Abschneiden der Nachkommastellen. Es wird nicht
gerundet im Gegensatz zur impliziten Typenumwandlung.
Beispiele: FIX(12.45) ==> 12; FIX(-12.89) ==> -12
- INT (<Ausdruck>) - gibt die größte Ganzzahl zurück, die kleiner
oder gleich dem Ausdruck ist. Mit INT kann man auch Run-
dungen aller Art durchführen; siehe Abschnitt
'Arithmetische Operatoren...'.
Beispiele: INT(12.45) ==> 12; INT(-12.89) ==> -13
- CDBL <Ausdruck> - numerischen Ausdruck in DOUBLE-Gleitpunktzahl
umwandeln (kann keinen numer. Stringausdruck
(z.B. "2*3") konvertieren!)
- CSGN <Ausdruck> - numerischen Ausdruck in SINGLE-Gleitpunktzahl
umwandeln
- CINT <Ausdruck> - Runden auf eine INTEGER-Ganzzahl
- CLNG <Ausdruck> - Runden auf eine LONG-Ganzzahl
- VAL (<String>) - String in Zahl umwandeln, z.B. VAL("2.34")
- STR$ (<Zahl>) - Zahl in String umwandeln, z.B. STR$(2.34)
- CQUD | CEXT | CFIX | CBCD - zusätzliche Typwandlungen für die
speziellen PowerBasic-Datentypen
Das QBasic-Kochbuch steht in der Tutorial-Rubrik von http://www.qbasic.de zum Download bereit. |
| Zitat: | Frage deutsch
~~~~~~~~~~~~~~
Was sind Gleitpunktzahlen und wie gehe ich damit um?
Question English
~~~~~~~~~~~~~~
What are floating-point numbers and can I handle them?
Antwort 1
~~~~~~~~
[ von Thomas Antoni und Helium ( m.beckah@gmx.de ); 20.5.2002 - 7.6.2002 ]
*** wie ist eine Gleitpunktzahl im Prinzip aufgebaut
Eine Gleitpunktzahl (auch "Fließkomma-Zahl", englisch "floating-point number" oder "real number" genannt) ist eine Zahl mit einer variablen Position des Dezimalpunktes. Eine Gleitpunktzahl hat zwei Bestandteile: Die eigentliche Wert wird durch die sogenannten "Mantisse" dargestellt und die Position des Dezimalpunktes durch den "Exponenten".
Hiermit lassen sich reelle Zahlen darstellen, wobei sich periodische Brüche aufgrund der endlichen Länge der Mantisse nur mit Rundungsfehlern ablegen und anzeigen lassen. 1/3 wird z.B. zu 0,33333330 .
Starte mal die folgende Befehlszeile in der QBasic-Entwicklungsumgebung :
PRINT 1!/2400000!
Der -> Suffix "!" kennzeichnet eine einfach lange 32 Bit Gleitpunktzahl (Datentyp SINGLE) mit einer Mantisse von 7 Dezimalstellen
Du erhältst die folgende Anzeige
4.166667 E-07
Du siehst hier die 7-stellige Mantisse 4.166667 und den Exponenten E-07. Das ganze ist gleichbedeutend mit
4,166667 x 10 ^ -7 , also 0,0000004166667 .
Wenn sich das Ergebnis innerhalb der in der Mantisse verfügbaren 7 Stellen darstellen lässt, wird in der Bildschirmanzeige der Exponent zur besseren Lesbarkeit weggelassen und der Dezimalpunkt an die korrekte Stelle gesetzt.
Die Befehlszeile
PRINT 1234!/100!
ergibt beispielsweise die Anzeige
12.34
In der Exponenzialdarstellung befindet sich der Dezimalpunkt übrigens grundsätzlich immer hinter der ersten Stelle (der Einerstelle) .
*** die Gleitpunkt-Datentypen bei QBasic
Bei QBasic gibt es die beiden Datentypen SINGLE (Variablennamen z.B. "egon!" oder "egon") und DOUBLE (Variablenname z.B. "paul#").
In meinem QBasic-Kochbuch findest Du zu SINGLE und DOUBLE die folgenden Information.
- egon! : SINGLE, einfach lange Gleitpunktzahl
(32 Bit, 7 Dezimalstellen Mantisse)
Wertebereich +-2,802597 *10^-45...+-3,402823 *10^38
- egon : dito (Suffix "!" ist bei SINGLE-Variablen weglassbar)
- paul# : DOUBLE, doppelt lange Gleitpunktzahl
(64 Bit, 16 Dezimalstellen Mantisse)
+-4,446590812571219 *10^-323...+-1,79769313486231 *10^308
Das QBasic-Kochbuch steht in der Tutorial-Rubrik von http://www.qbasic.de zum Download bereit.
Wenn man den -> Suffix " ! " oder " # " hinter dem Variablennamen weglässt, dann ordnet QBasic der Variablen automatisch den Typ SINGLE zu. Wenn für eine Berechnung der Datentyp -> Integer (Ganzzahl) ausreicht, solltest Du im Variablennamen immer den zugehörigen Suffix " % " oder " & " verwenden, weil die Gleitpunktverarbeitung erheblich mehr Rechenleistung verbraucht als die Integerarithmetik.
-> PowerBasic unterstützt übrigens zusätzlich noch EXTENDED Gleitpunktzahlen mit einer Datenlänge von 80 Bits.
Bei der Arithmetik mit Gleitpunktzahlen sind Rundungsfehler nicht immer ververmeidbar. Siehe dazu den Eintrag "Warum kommt es bei Gleitpunktoperationen zu Rundungsfehlern?" in der Kategorie "Zahlen verarbeiten ..." .
*** Interne Darstellung von Gleitpunktzahlen
Im Computer werden die Gleitpunktzahlen natürlich als 0/1-Kombinationen hinterlegt und verarbeitet, wobei ein Teil des 32 bzw. 64 Bit langen Bitfeldes für die Mantisse und der Rest für den Exponenten reserviert ist. Der Exponent bezieht sich natürlich in Wirklichkeit auf die Basis 2 und nicht nicht wie oben angegeben auf die Basis 10. Die Dezimaldarstelung existiert nur auf der Anwenderoberfläche, nicht intern in der CPU.
Intern werden die Gleitpunktzahlen also wie folgt abgelegt:
Vorzeichen x Mantisse x 2 ^ (Vorzeichen x Exponent)
Außerdem speichern solche Zahlen für gewöhnlich auch noch Sonderzustände, wie
keine Zahl (NAN, not a number) oder Unendlich (INF, infinity)
1.0 / 0 = INF
-1.0 / 0 = -INF
Wie die Gleitpunktzahlen intern dargestellt sind, braucht den Programmierer normalerweise nicht zu interssieren. Erst wenn externe Bibliotheken verwendet werden die z.B. in C/C++ oder Assembler geschrieben sind, muss man sich darum kümmern, dass die Gleitpunktformate -> kompatibel sind. Bis QuickBasic 3.0 gab es bei Microsoft das spezielle MBF-Format für die Gleitpunktzahlen. Erst ab QuickBasic 3.0 wechselte Microsoft zum heute am häufigsten verwendeten IEEE-Format (sprich "ai-trippel-ie"). In "Antwort 2" erhältst Du dazu detaillierte Informationen.
*** Die Gleitpunktformate IEEE und MBF
Zu dieser Thematik der folgende Beitrag aus der Newsgroup news:comp.lang.basic.misc :
.
MBF stands for Microsoft Binary Format which is an alternate Floating Point Format to the IEEE 747 standard formats. It was commonly used in the 70's and may be run across in old software/data files. More information on the format can be retrieves from http://www.borland.com or ftp.borland.com along with C source code to convert between the two. Perhaps Peter will translate in the Code FAQ for uses of other Basics. The Microsoft Binary Format was given up for the IEEE formats because its accuracy was not as good and to comply with the Intel 80x87 FPU for faster calculations using the FPU (Floating-Point Unit).
*** Nutzt QBasic den Mathematischen Coprozessor?
Ab dem 486er Prozessor haben alle Intel CPUs einen integrierten Mathematischen Coprozessor, der die Gleitpunktoperation hardwaremäßig und daher sehr schnell abarbeitet. Bei den Vorgänger-CPUs gab die speziellen Coprozessoren 8087, 80287 und 80387 als getrennte Chips.
QBasic erkennt leider nur die externen Coprozessoren 8087 bis 80387, nicht jedoch die On-Chip-Copros moderner CPUs ab. Die die Gleitpunktarithmetik wird dort daher sehr, sehr langsam per Software -> emuliert .
Es gibt jedoch ein kleines Progrämmchen namens FFIX.COM , das den Numerischen Coprozessor für QBasic aktiviert, wenn man es vor dem Start des QBasic-Programms aufruft. Weitere Informationen über FFIX.COM findest Du im Beitrag "Wie kann mein QB-Programm den Arithmetik-Coprozessor nutzen?" in der Kategorie "Sonstiges" .
*** Allgemeine Informationen zu Gleitpunktzahlen
Eine Gleitpunktzahl, ist eine Zahl,die durch eine Mantisse und einen Exponenten entsprechend einer vorgegebenen Basis dargestellt wird. Die Mantisse hat in der Regel einen Wert zwischen 0 und 1. Um den Wert einer Gleitkomma-Zahl zu ermitteln, wird die Basis mit dem Exponenten potenziert und die Mantisse mit dem Ergebnis multipliziert. Entsprechend der konventionellen Notation werden Gleitkomma-Zahlen mit dem Wert 10 als Basis verwendet. In der Informatik hat die Basis für Gleitkomma-Zahlen in der Regel den Wert 2.
Die "Gleitpunkt-Notation" (engl. "floating-point notation") wird auch als "Exponenzial-Schreibweise" bezeichnet. Es handelt sich dabei um ein numerisches Format, das sich für die Darstellung sehr großer und sehr kleiner Zahlen eignet. Die Speicherung von Gleitpunkt-Zahlen erfolgt in zwei Teilen - Mantisse und Exponent. Die Mantisse legt dabei die einzelnen Ziffern der Zahl fest, und der Exponent gibt deren Größenordnung (d.h. die Position des Dezimalpunkts) an. Beispielsweise lassen sich die Zahlen 314600000 und 0,0000451 in Gleitkomma-Notation als 3146E5 und 451E-7 schreiben. Viele Mikroprozessoren können keine Gleitkomma-Arithmetik ausführen, so daß man entsprechende Berechnungen entweder per Software nachbildet oder einen speziellen Gleitkomma-Prozessor einsetzt. |
_________________
Die gefährlichsten Familienclans | Opas Leistung muss sich wieder lohnen - für 6 bis 10 Generationen! |
|
| Nach oben |
|
|
noop
Anmeldungsdatum: 04.05.2005
Beiträge: 259
|
| Verfasst am: 31.05.2005, 20:45 Titel: |
|
|
Hi
Danke jetzt hab ichs gleub ich alles gecheckt.
Kann bloß zur Zeit die QB Mon FAQ nicht ausführen.
(FORMAT C:  und der PC an dem ich hier sitze ist einfach zu lahm und kackt meistens beim öffnen des Progs ab.  ) |
|
| Nach oben |
|
|
|
|
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
|
|
FAQ
Suchen
Mitgliederliste
Benutzergruppen
Registrieren
Profil
Einloggen, um private Nachrichten zu lesen
Login
