Import / Export Funktion
Subroutine - Programmcodes an mehren Stellen verwenden
Systeminformationen ermitteln
Die Anzahl der Prozessoren ermitteln
Die Prozessor- Beschreibung ermitteln
Die Prozessor- Familie ermitteln
Das Prozessor- Modell ermitteln
Das Prozessor- Stepping ermitteln
Die aktuelle Prozessor- Geschwindigkeit ermitteln
Die Gesamt- Größe des Arbeitsspeichers ermitteln
Die Größe des noch freien Arbeitsspeichers ermitteln
Die Größe des bereits verwendeten Arbeitsspeichers ermitteln
Die Größe des Cache- Speichers ermitteln
Die horizontale Bildschirmauflösung ermitteln
Die vertikale Bildschirmauflösung ermitteln
Die eingestellte Farbtiefe ermitteln
Die Bildwiederholfrequenz ermitteln
Den Namen des Betriebssystems ermitteln
Die Version des Betriebssystems ermitteln
Den Rechner- Namen (Hostnamen) ermitteln
Die IP- Adresse ermitteln
Die MAC- Adresse ermitteln
Die SubNet- Mask ermitteln
Das Standard- Gateway ermitteln
CPU Auslastung ermitteln
Import / Export verwenden
Die Import- / Export-Funktion in yab soll ihnen das Programmierleben erleichtern, indem Sie Subroutinen aus ihrem Programmcode in andere Dateien auslagern und so später besser bearbeiten können.
Importieren von Subroutinen:
import ausgelagerte_sub
Variable=10
Variable2=20
ausgelagerte_sub()
Der Dateiname der zu importieren Datei muss gleich dem Dateinamen sein, d.h. die Datei für die obengenannte Subroutine muss wir folgt lauten:
ausgelagerte_sub.yab
In der Datei ausgelagerte_sub.yab können Sie jetzt die Subroutine beschreiben.
export sub ausgelagerte_sub()
print "Hallo zusammen"
end sub
Damit yab weiß das Sie die Subroutine exportieren und in einem anderen yab Programm importieren und ausführen möchten müssen Sie vor der Subroutine noch export, wie im obigen Beispiel, vorschreiben. Der zuvor gezeigte Quellcode gibt nach dem Import Hallo zusammen aus.
Wenn Sie jetzt Variable in der ausgelagerten Subroutine verwenden möchten, so müssen Sie die Variablen bekannt machen und aus dem Hauptprogramm übergeben.
Hauptprogramm.yab
import ausgelagerte_sub
Variable=10
Variable2=20
ausgelagerte_sub(Variable, Variable2)
ausgelagerte_sub.yab
export sub ausgelagerte_sub(Variable, Variable2)
print Variable
print Variable2
end sub
Erst jetzt kann die Subroutine mit den Variablen umgehen. Sie können jetzt Berechnungen oder sonstige Dinge mit den Variablen machen. Sie können auch in der Datei ausgelagerte_sub.yab auch noch weitere Subroutinen erstellen und verwenden. Die weiteren Subroutinen müssen dann aber von der ersten Subroutine, die Exportiert worden ist, aufgerufen werden.
zurück zur Übersicht
Subroutine - Programmcodes an mehren Stellen verwenden
Mit Hilfe von Subroutinen, ist es möglich, bestimmte Programmcodes an mehreren Stellen einzubinden. Ein gutes Beispiel dafür ist das schließen von "Views". Jedes Mal wenn sie Views öffnen und dann zum Beispiel nach einer Auswahl (Button, Menü usw.) einen neuen View laden, müssen Sie den vorherigen schließen um Überlagerungen zu vermeiden. Hier kann eine Subroutine eine große Hilfe sein, denn diese können Sie vor dem öffnen eines neuen Views einbinden um alle im Programm möglichen Views zu schließen, ohne darauf achten zu müssen ob alle dort eingetragenen Views derzeit in Verwendung sind.
Eine Subroutine fügen Sie wie folgt außerhalb der Mainloop ein:
sub Name der Subroutine()
Programmcode
end sub
Mit sub Name der Subroutine(), erstellen Sie eine Subroutine mit einem Namen Ihrer Wahl. Dies könnte zum Beispiel RemoveViews() sein. Mit end sub beenden Sie den Subroutinenbereich. Zwischen diese beiden Befehle, schreiben Sie den Programmcode, welchen Sie durchführen möchten.
Bei dem Beispiel mit den Views würde der Programmcode dann zum Beispiel so aussehen:
sub RemoveViews()
view remove "View1"
view remove "View2"
view remove "View3"
end sub
Nachdem Sie die Subroutine erstellt haben, müssen Sie diese noch an der Stelle im Programmcode einbinden, an welcher Sie diese ausführen möchten.
Dies erfolgt mit der einfachen Angabe der Subroutine:
Name der Subroutine()
Sie werden schnell feststellen, dass dies nicht nur eine Erleichterung beim schreiben von wiederkehrenden Abfragen oder Aktionen darstellt, sondern auch den Programmcode ordentlicher und übersichtlicher macht. Es kann auch hilfreich sein, einfach ausgeführte Aufgabenstellungen in Subroutinen zu verlagern, da so der Mainloop leichter zu überblicken ist.
zurück zur Übersicht
Systeminformationen ermitteln
Beitrag von Chaotic Oktober 2009
Leider bietet yab, auch in der aktuellen Version 1.5, nur wenige Informationen zum Computer-System an (Diese wird/will Jan aber noch einbauen). Bis es jedoch soweit ist, muss trotzdem niemand auf solche Informationen verzichten, denn mit ein paar Zeilen Code lassen sich diese selbst ermitteln.
Im Folgenden möchte ich zeigen wie man z.B. die Größe bzw. den freien oder bereits belegten Speicher ermitteln kann, die Anzahl der Prozessoren ermittelt oder herausbekommt auf welche MAC- bzw. IP- Adresse der Rechner hört.
All die kleinen, im Folgenden aufgeführten Beispiele sind auch als solche zu verstehen. Sie sollen lediglich Anregung sein das Eine oder Andere selbst einmal auszuprobieren. Dabei sind Erweiterungen und Verbesserungen selbstverständlich gern gesehen und willkommen.
Die Anzahl der Prozessoren ermitteln
Mit der nachstehenden kleinen Routine kann man auf sehr einfache Weise die Anzahl der Prozessoren im System ermitteln:
<----- Quellcode ----->
export sub yGetCPUCount()
return val(left$(system$("sysinfo -cpu"), 1))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUCount()
print yGetCPUCount()
Über den Befehl "print yGetCPUCount()" bekommen wir die Anzahl der CPUs im Terminal ausgegeben. Möchte man dies anderweitig machen, muss dieser Bereich dementsprechend angepasst werden. Die Ausgabe erfolgt hier als einfache Zahl, der Wert der Zahl ist gleich die Anzahl der CPUs.
Die Prozessor- Beschreibung ermitteln
Um die Beschreibung des Prozessors zu ermitteln verwenden wir die folgende Sub- Routine:
<----- Quellcode ----->
export sub yGetCPUDescription$()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -cpu"), lines$(), chr$(10))
return mid$(lines$(2), 10, len(lines$(2)) - 10)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUDescription$()
print yGetCPUDescription$()
Über den Befehl "print yGetCPUDescription$()" bekommen wir die Beschreibung des Prozessors im Terminal ausgegeben. Dies kann wie folgt aussehen: "Intel® Core 2 Quad CPU @ 2.66GHz". Dies würde also bedeuten, das in abgefragten Rechner ein "Intel® Core 2 Quad" mit 2,66 GHz seine Arbeit verrichtet.
Die Prozessor- Familie ermitteln
Jeder Prozessor verfügt weiterhin über Informationen wie Family, Model und Stepping. Mit der folgenden, kleinen Routine kann man die Prozessor- Familie ermitteln.
<----- Quellcode ----->
export sub yGetCPUFamily()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("sysinfo -cpu"), lines$(), chr$(10))
counter2 = token(lines$(3), lines2$(), ",")
for i = 1 to counter2
if (instr(lines2$(i), "family")) then
result = val(mid$(lines2$(i), instr(trim$(lines2$(i)), " ") + 2, len(trim$(lines2$(i))) - instr(trim$(lines2$(i)), " ")))
end if
next i
return result
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUFamily()
print yGetCPUFamily()
Über den Befehl "print yGetCPUFamily()" bekommen wir die Prozessor- Familie ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "6". Dieses Ergebnis ordnet den Prozessor der Intel internen Familie 6 zu. Was diese Information im Einzelnen zu bedeuten hat, erfährt man sicher bei Intel.
Das Prozessor- Modell ermitteln
Wie bereits im oberen Beispiel erwähnt, hier nun die Funktion um auch das Prozessor- Modell zu ermitteln:
<----- Quellcode ----->
export sub yGetCPUModel()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("sysinfo -cpu"), lines$(), chr$(10))
counter2 = token(lines$(3), lines2$(), ",")
for i = 1 to counter2
if (instr(lines2$(i), "model")) then
result = val(mid$(lines2$(i), instr(trim$(lines2$(i)), " ") + 2, len(trim$(lines2$(i))) - instr(trim$(lines2$(i)), " ")))
end if
next i
return result
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUModel()
print yGetCPUModel()
Über den Befehl "print yGetCPUModel()" bekommen wir das Prozessor- Modell ermitteln und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "15". Dieses Ergebnis ordnet dem Prozessor das Intel interne Modell 15 zu. Was diese Information im Einzelnen zu bedeuten hat, erfährt man sicher bei Intel.
Das Prozessor- Stepping ermitteln
Ebenfalls wie bereits im oberen Beispiel erwähnt, hier nun die Funktion um auch das Prozessor- Stepping zu ermitteln:
<----- Quellcode ----->
export sub yGetCPUModel()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("sysinfo -cpu"), lines$(), chr$(10))
counter2 = token(lines$(3), lines2$(), ",")
for i = 1 to counter2
if (instr(lines2$(i), "stepping")) then
result = val(mid$(lines2$(i), instr(trim$(lines2$(i)), " ") + 2, len(trim$(lines2$(i))) - instr(trim$(lines2$(i)), " ")))
end if
next i
return result
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUStepping()
print yGetCPUStepping()
Über den Befehl "print yGetCPUStepping()" bekommen wir das Prozessor- Stepping ermitteln und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "7". Dieses Ergebnis ordnet dem Prozessor dem Intel interne, Stepping 7 zu. Was diese Information im Einzelnen zu bedeuten hat, erfährt man sicher bei Intel.
Die aktuelle Prozessor- Geschwindigkeit ermitteln
Warum die aktuelle Prozessor- Geschwindigkeit? Weil diese von der in der Prozessor- Beschreibung angegebenen Taktfrequenz abweicht und sich während des Betriebes, bei modernen Prozessoren, ändern kann. Die nachstehende Routine liefert das gewünschte Ergebnis.
<----- Quellcode ----->
export sub yGetCPUActualSpeed()
local i
local sys$
sys$ = system$("sysinfo -cpu")
for i = instr(sys$, "MHz") - 1 to 1 step -1
if mid$(sys$, i, 1) = chr$(32) then
break
end if
next i
return val(mid$(sys$, i + 1, instr(sys$, "MHz") - 1 - i))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetCPUActualSpeed()
print yGetCPUActualSpeed()
Über den Befehl "print yGetCPUActualSpeed()" bekommen wir die aktuelle Prozessor- Geschwindigkeit ermitteln und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "2668". Dies bedeutet also, dass der Rechner im Moment mit 2668 MHz arbeitet.
Die Gesamt- Größe des Arbeitsspeichers ermitteln
Die folgende Routine ermittelt die Größe des gesamten verfügbaren Arbeitsspeichers im System:
<----- Quellcode ----->
export sub yGetMemoryTotal()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -mem"), lines$(), " )")
return val(lines$(7))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMemoryTotal()
print yGetMemoryTotal()
Über den Befehl "print yGetMemoryTotal()" bekommen wir die Gesamt- Größe des Arbeitsspeichers ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "650051584". Die Angabe erfolgt in Byte. Dies würde also bedeuten, dass in meinem Rechner 620 MB Arbeitsspeicher vorhanden sind.
Die Größe des noch freien Arbeitsspeichers ermitteln
Ebenso wie die gesamte Größe des Arbeitsspeichers lässt sich auch der noch freie Arbeitsspeicher ermitteln. Die folgende Routine übernimmt diese Aufgabe:
<----- Quellcode ----->
export sub yGetMemoryFree()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -mem"), lines$(), " )")
return val(lines$(1))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMemoryFree()
print yGetMemoryFree()
Über den Befehl "print yGetMemoryFree()" bekommen wir die Größe des noch freien Arbeitsspeichers ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "546045952". Auch in diesem Fall sind die Angaben wieder in Bytes. So sind im Moment ca. 520 MB des Arbeitsspeichers noch frei.
Die Größe des bereits verwendeten Arbeitsspeichers ermitteln
Auch die Größe/Menge des bereits belegten Arbeitspeichers kann mit Hilfe einer kleinen Routine ermittelt werden:
<----- Quellcode ----->
export sub yGetMemoryUsed()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -mem"), lines$(), " )")
return val(lines$(5)) end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMemoryUsed()
print yGetMemoryFree()
Über den Befehl "print yGetMemoryUsed()" bekommen wir die Größe des bereits verwendeten Arbeitsspeichers ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "104005632". Auch hier sind die Angaben wieder in Bytes. Gut, irgendein Schlauberger könnte jetzt sagen, warum so eine Routine. Man kann doch einfach den noch freien vom gesamten Arbeitsspeicher abziehen und erhält dasselbe Ergebnis. Ja, aber warum einfach wenn es auch umständlich auch geht, und schließlich wollen wir doch programmieren lernen ^^.
Die Größe des Cache- Speichers ermitteln
Ja, auch die Größe des verwendeten Cache- Speichers lässt sich ermitteln, und zwar mit der folgenden kleinen Routine:
<----- Quellcode ----->
export sub yGetMemoryCached()
local counter
local lines$
dim lines$(1)
counter = token(system$("sysinfo -mem"), lines$(), " )")
return val(lines$(10))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMemoryUsed()
print yGetMemoryUsed()
Über den Befehl "print yGetMemoryUsed()" bekommen wir die Größe des Cache- Speichers ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "32636928". Wie bereits bei den vorangegangenen Beispielen sind auch hier die Angaben wieder in Bytes. Das System belegt in diesem Fall also ca. 31 MB für den Cache-Speicher.
Die horizontale Bildschirmauflösung ermitteln
Diese Information bekommt man prinzipiell über den PEEK()- Befehl, aber wie im folgenden Beispiel zu sehen, kann man dies auch über das System abfragen:
<----- Quellcode ----->
export sub yGetScreenWidth()
local counter
local lines$
dim lines$(1)
counter = token(system$("screenmode"), lines$(), " ")
return val(lines$(2))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetScreenWidth()
print yGetScreenWidth()
Über den Befehl "print yGetScreenWidth()" bekommen wir die horizontale Bildschirmauflösung ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "1152". Die Bildschirmauflösung beträgt horizontal also eine Größe von 1152 Pixeln.
Die vertikale Bildschirmauflösung ermitteln
Auch diese Information bekommt man prinzipiell über den PEEK()- Befehl, aber wie im folgenden Beispiel zu sehen, kann man dies auch über das System abfragen:
<----- Quellcode ----->
export sub yGetScreenHeight()
local counter
local lines$
dim lines$(1)
counter = token(system$("screenmode"), lines$(), " ")
return val(lines$(3))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetScreenHeight()
print yGetScreenHeight()
Über den Befehl "print yGetScreenHeight()" bekommen wir die vertikale Bildschirmauflösung ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendete Rechner ergab einen Zahlenwert von "864". Die Bildschirmauflösung beträgt vertikal also eine Größe von 864 Pixeln.
Die eingestellte Farbtiefe ermitteln
Ebenso wie die horizontale und vertikale Bildschirmauflösung lässt sich auch die eingestellte Farbtiefe ermitteln:
<----- Quellcode ----->
export sub yGetColorDepth()
local counter
local lines$
dim lines$(1)
counter = token(system$("screenmode"), lines$(), " ")
return val(lines$(4))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetColorDepth()
print yGetColorDepth()
Über den Befehl "print yGetScreenHeight()" bekommen wir die eingestellt Farbtiefe ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendeten Rechner ergab einen Zahlenwert von "32". Die eingestellte Farbtiefe auf dem Rechner beträgt demnach 32 Bit = 4294967296 Farben (sofern darstellbar).
Die Bildwiederholfrequenz ermitteln
Und auch die eingestellte Bildwiederholfrequenz lässt sich über folgende kleine Routine ermitteln:
<----- Quellcode ----->
export sub yGetScreenRefreshRate()
local counter
local lines$
dim lines$(1)
counter = token(system$("screenmode"), lines$(), " ")
return val(lines$(6))
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetScreenRefreshRate()
print yGetScreenRefreshRate()
Über den Befehl "print yGetScreenRefreshRate()" bekommen wir die Bildwiederholfrequenz ermittelt und im Terminal ausgegeben. Der für diese Abfrage verwendeten Rechner ergab einen Zahlenwert von "60". Die eingestellte Bildwiederholrate in dem System liegt dem zu folge bei 60 Hz.
Den Namen des Betriebssystems ermitteln
Nun ja, hier ist der Name Programm und folgende kleine Routine nimmt uns die Arbeit ab:
<----- Quellcode ----->
export sub yGetOSName$()
return system$("uname -o")
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetOSName$()
print yGetOSName$()
Über den Befehl "print yGetOSName$()" bekommen wir den Namen des Systems ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendeten Rechners ergab "Haiku". Dies sagt uns also, das der Name unseres Betriebssystems ist "Haiku".
Die Version des Betriebssystems ermitteln
Und natürlich lässt sich auch die Version des Betriebssystems mit Hilfe folgender, kleiner Routine ermitteln:
<----- Quellcode ----->
export sub yGetOSVersion$()
local counter
local lines$
dim lines$(1)
counter = token(system$("uname -v"), lines$(), " ")
return lines$(1)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetOSVersion$()
print yGetOSVersion$()
Über den Befehl "print yGetOSVersion$()" bekommen wir die Version des Betriebssystems ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendete Rechners ergab "r33109". Die verwendete Version des Betriebssystems ist also r33109.
Den Rechner- Namen (Hostnamen) ermitteln
Mit einer weiteren, recht einfachen Funktion ermitteln wir der Namen unseres Rechners:
<----- Quellcode ----->
export sub yGetHostname$()
return system$("hostname")
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetHostname$()
print yGetHostname$()
Über den Befehl "print yGetHostname$()" bekommen wir den Rechner- Namen (Hostname) ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendete Rechners ergab "shredder". Wie wir sehen heißt der Rechner shredder. Wer auch immer ihm diesen Namen verpasst hat, er heißt seit der Installation so, und ich schwöre, ich war es nicht.
Die IP- Adresse ermitteln
Folgende kleine Routine ermittelt die IP- Adresse des Rechners. Wobei hier der "loop"- Adapter nicht berücksichtigt wird, und auch nur die IP- Adresse der ersten Netzwerkkarte ermittelt wird. Wer will kann diese Funktion gern erweitern, sodass eventuell auch mehrere Netzwerkkarten berücksichtigt werden.
<----- Quellcode ----->
export sub yGetIPAddress$()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("ifconfig"), lines$(), chr$(10))
for i = 1 to counter
if (instr(lines$(i), "inet addr:")) and (instr(lines$(i), "Bcast:")) then
counter2 = token(lines$(i), lines2$(), ", ")
end if
next i
return lines2$(3)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetIPAddress$()
print yGetIPAddress$()
Über den Befehl "print yGetIPAddress$()" bekommen wir die IP Adresse des Rechners ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendeten Rechners ergab "10.0.2.15". Die IP- Adresse des Rechners ist also 10.0.2.15.
Die MAC- Adresse ermitteln
Mit folgender kleiner Routine ermittelt man die MAC- Adresse des Rechners. Wobei auch hier der "loop"- Adapter nicht berücksichtigt wird, und auch nur die MAC-Adresse der ersten Netzwerkkarte ermittelt wird. Wer will kann auch diese Funktion gern erweitern, sodass eventuell auch mehrere Netzwerkkarten berücksichtigt werden.
<----- Quellcode ----->
export sub yGetMACAddress$()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("ifconfig"), lines$(), chr$(10))
for i = 1 to counter
if (instr(lines$(i), "Hardware Type: Ethernet, Address:")) then
counter2 = token(lines$(i), lines2$(), " ")
end if
next i
return lines2$(5)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetMACAddress$()
print yGetMACAddress$()
Über den Befehl "print yGetMACAddress$()" bekommen wir die MAC Adresse des Rechners ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendeten Rechners ergab "08:00:27:9e:26:4d". Die MAC- Adresse des Rechners ist also 08:00:27:9e:26:4d.
Die SubNet- Mask ermitteln
Auch das Ermitteln der SubNet- Mask lässt sich über eine kleine Funktion bewerkstelligen:
<----- Quellcode ----->
export sub yGetSubNetMask$()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("ifconfig"), lines$(), chr$(10))
for i = 1 to counter
if (instr(lines$(i), "inet addr:")) and (instr(lines$(i), "Bcast:")) then
counter2 = token(lines$(i), lines2$(), ", ")
end if
next i
return lines2$(7)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetSubNetMask$()
print yGetSubNetMask$()
Über den Befehl "print yGetSubNetMask$()" bekommen wir die SubNet- Mask des Rechners ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendeten Rechners ergab "255.255.255.0". Die SubNet- Mask des Rechners ist also 255.255.255.0.
Das Standard- Gateway ermitteln
Und zum Schluss ermitteln wir nun noch mit Hilfe der nachstehenden Routine das Standard- Gateway:
<----- Quellcode ----->
export sub yGetDefaultGateway$()
local counter
local counter2
local lines$
local lines2$
local result
dim lines$(1)
dim lines2$(1)
counter = token(system$("route"), lines$(), chr$(10))
for i = 1 to counter
if (instr(lines$(i), "gateway")) and (instr(lines$(i), "default")) then
counter2 = token(lines$(i), lines2$(), ", ")
&nnbsp;end if
next i
return lines2$(5)
end sub
<----- Quellcode ----->
Aufruf und Ausgabe der Subroutine:
yGetDefaultGateway$()
print yGetDefaultGateway$()
Über den Befehl "print yGetSubNetMask$()" bekommen wir das Standard- Gateway des Rechners ermittelt und im Terminal ausgegeben. Die Ausgabe bei dem für diese Abfrage verwendete Rechners ergab "10.0.2.2". Das Standard- Gateway des Rechners ist also 10.0.2.2.
Nachwort
Alle hier gezeigten Routinen sind selbstverständlich getestet und geprüft. Trotzdem kann ich Fehler, welche eventuell durch Tippfehler entstanden sind, nicht gänzlich ausschließen. Dies bitte ich gegebenen Falls zu entschuldigen. Alle Routinen wurden mit der yab- Version 1.5 erstellt und unter der HAIKU- Version R1 / Alpha1 Revision 33109 getestet.
Ermitteln der CPU- Auslastung
Beitrag von René Passier Oktober 2010
Nachdem das Ermitteln verschiedener Systeminformationen, siehe Systeminformationen ermitteln, an und für sich kein großes Problem mehr darstellt, hier nun eine weitere kleine Routine mit welcher es möglich ist, die aktuelle CPU- Auslastung zu ermitteln.
Passenderweise trägt die neue "Sub" den Namen _GetCPUUtilization und erledigt auch genau diese Aufgabe.
export sub _GetCPUUtilization()
// Variablen definieren
local SystemInput$
local NumberOfTokens
local Line$
dim Lines$(1) dim Position$(1)
// den Befehl "TOP" ausführen und Ausgabe in SystemInput$ speichern
SystemInput$ = system$("top -d -n 1 -i 1")
// SystemInput$ in einzelne Zeilen zerlegen
NumberOfTokens = token(SystemInput$, Lines$(), chr$(10))
// aus der letzten Zeile die gewünschte Information extrahieren
NumberOfTokens = token(Lines$(NumberOfTokens), Position$(), chr$(32))
// Ergebnis zurückliefern
return val(Position$(5))
end sub
Der Aufruf der Sub- Routine erfolgt dabei ohne Parameterübergabe, in der Form:
Variable = _GetCPUUtilization()
oder:
print _GetCPUUtilization()
Der dabei ausgegebene Wert entspricht der aktuellen CPU- Auslastung in % und wird als Gleitkommazahl zurückgegeben.
zurück zur Übersicht
YAB Hilfestellungen erstellt durch Christian Albrecht (Lelldorin) und Lorenz Glaser 2005-2017
Bereitgestellt durch BeSly, der BeOS & Zeta Wissensbasis.