Drucken
Hauptkategorie: Entwicklung
Kategorie: yab
Zugriffe: 3318

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.

zurück zur Übersicht


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.

zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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

zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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


zurück zur Übersicht


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.


zurück zur Übersicht


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


zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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.


zurück zur Übersicht


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.

zurück zur Übersicht


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.


zurück zur Übersicht


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.

zurück zur Übersicht


 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.