Ressourcenmonitor

Heute ist Stammtischzeit:
Jeden Donnerstag 20:30 Uhr hier im Chat.
Wer Lust hat, kann sich gerne beteiligen. ;)
  • Hey Leute,
    also ich hab die Idee meinen Pi als Ressourcenmonitor zu benutzen. Ich hab das bei mehren Gamingkeyboards gesehen und finde die zu teuer (außerdem finde ich meine Tastatur momentan noch total super).
    Frage ist würde das ganze denn gehen und wenn ja wie ?

    Würde mich über eine Antwort freun. :^^:

    Nerver trust running Systems :angel:

  • Also ich möchte das mein Pi mir meine Daten vom Pc anzeigt. Heißt er soll mir die Wärme und Taktrate von der Cpu an zeigen , das selbe von der Gpu inkl. FPS, Wie schnell sich die Lüfter drehen und die Taktrate vom Ram. :)

    Nerver trust running Systems :angel:

  • Bei solchen Gaming-Tastaturen wird eine Software des Herstellers installiert, die dann das Display auf der Tastatur ansteuert. Zum Beispiel "Arx Control" von Logitech. Da die Software aber nur mit dazu passenden Produkten funktioniert kannst du es für dein Vorhaben quasi knicken.

    Du brauchst also eine Software auf deinem PC, was die erforderlichen Informationen vom PC ausließt und an den Pi übermittelt und dort dann auf einem Display visualisiert...

    Ich hatte mal ein Windows Gadget geschrieben um die Informationen des Pi's auf dem Windows-Rechner anzuzeigen. Vermutlich könntest du sowas ähnliches, nur anders herum, umsetzen - allerdings brauchst du dann halt ein Programm/Script das auf deinem Windows-PC permanent läuft. Wenn du diese Informationen auch unter Ubuntu auslesen willst würde sich eine Programmiersprache anbieten die auf beiden Systemen läuft, also eine Tendenz zu Python und Sockets :fies:

  • Hmm ich hab ne ältere Logitech Tastatur (G11) die ich momentan auch benutze...
    kann ich theoretisch Remix OS auf einem pi installieren ?
    wenn ja könnte ich mir ja Arx Controll da als App runterladen :D
    wäre deutlich einfacher oder ist python einfach zu lernen ?

    Nerver trust running Systems :angel:

  • Physikalische Daten zum System kann man bei Windows per WMI auslesen. Guck dir mal den Netmonitor von Spiceworks an, der verbindet sich der Windows Kiste per WMI und liest die Daten dann aus und stellt sie auf einer Webseite dar. Jetzt weiß ich aber nicht ob Spiceworks auf nem Raspberry läuft, das braucht schon ordentlich Ressourcen.
    Mit Hausmitteln auf den Windows PC zugreifen würde evtl. noch mit SNMP gehen, aber da sollte man nur noch SNMP v2 aufwärts verwenden mit auth. Ich würd hier nicht basteln und erstmal bei spiceworks schauen was die so anbieten.

  • Oder einfach mal googlen: "python get windows system information" oder "python get windows cpu temp"

    Da gibt es viele verschiedene Möglichkeiten... Es gibt zB ein WMI Python Module, oder 'platform', etcpp. Ich bevorzuge psutil. pyspectator scheint auch geeignet zu sein.

    //EDIT: Open Hardware Monitor pusht Informationen ins WMI die dann abrufbar wären...


    [/spoiler]

    Alternativ ein fork davon: http://www.cputhermometer.com

    Und last but not least scheint IronPython besser geeignet zu sein um auf .NET Zugriff zu haben.

    Vielleicht kann man sich auch hier was abgucken: https://github.com/nicolargo/glances

    Ein Blick auf https://wmie.codeplex.com lohnt sich ebenfalls

    Weitere Links:
    http://www.cfos.de/de/cfos-personal-net/wmi.htm

  • Da mich das Thema selbst interessiert habe ich in den letzten Tagen etwas weiter recherchiert und weitere interessante Details Beitrag#13 eingefügt.

    WMI scheint die einfachste und umfangreichste Möglichkeit zu sein Informationen vom Windows-System abzurufen. Andere Möglichkeiten wie über die registry sind sehr umständlich und nicht derart umfassend.

    Im Prinzip könnte man zB von "cFos Personal Net" die wmi Web-Dateien kopieren und auf dem Pi in einem Kiosk-Mode darstellen lassen ( liegen in "C:\ProgramData\cFos\cfospnet\pub\wmi\" und "C:\ProgramData\cFos\cfospnet\pub\scripts\" )

    Da ich sowas aber gerne selber bastel um die Hintergründe zu verstehen hab ich mir vorgenommen in Tkinter solch ein Fenster zu basteln wie es mit "Open Hardware Monitor" der Fall ist:

    Wie man unschwer erkennen kann sind die angezeigten Informationen sortiert - weitaus besser lesbar als im Spoiler von Beitrag#13 zu sehen. Dh bereits beim abrufen der Informationen via WMI müsste man diesen " Tree " erstellen damit die GUI Generierung dann wie von selbst stattfinden kann, so zumindest die Idee.

    Wenn man sich mit dem WMI-Explorer mal die von OpenHardwareMonitor bereitgestellten Informationen betrachtet, wird zwischen 'Hardware' und 'Sensors' unterschieden und genau das wird in der OHM GUI auch angewendet:
    "HardwareType: CPU" steht ganz oben, der "Parent" Wert ist leer und dessen "Identifier" lautet "/intelcpu/0". Schaut man nun in 'Sensor' und sucht dort nach genau diesem "Identifier" aber als "Parent", findet man die dazugehörigen Sensor-Werte.

    Das heißt ein Parent="" markiert ein Hardware-Node wie zB die Grafikkarte oder den CPU. Ist "Parent" aber nicht leer handelt es sich um einen Sensor.

    Es gibt aber leider gewisse Einschränkungen was die Qualität der abrufbaren Informationen betrifft, weshalb es viele so machen dass auf dem Windows-Computer ein Python Script zum abrufen der Werte läuft - meistens eine Kombination von wmi und psutil. Dieses windows.py Script stellt dann einen Schnittstelle zur Verfügung worüber andere Scripts die Infos abrufen können.
    Über diesen Weg fällt auch der umständliche Installations-Wahn für WMI auf Linux Systemen weg, das ist nämlich nicht ganz so trivial wie unter Windows, sprich, unter Windows die nötigen python wmi Module zu installieren ist weitaus einfacher als unter Linux... Siehe dazu http://www.adamtheautomator.com/query-wmi-linux-python/
    Ein weiterer Vorteil der "Zusatz Script" Vorgehensweise ist, dass kein Administrator & Password Zugang zum Windows-PC auf dem Pi abgelegt werden muss.

    Das einzige was auf dem Windows Computer eingerichtet werden muss ist eigentlich nur OpenHardwareMonitor. Ich gehe aber auch den eben beschrieben Weg über ein windows.py Script auf dem jeweiligen Windows-PC.


    Plattform Windows:

    Open Hardware Monitor installieren bzw starten.

    Ich empfehle folgendes Python für Windows zu installieren: python-3.6.2rc2-amd64-webinstall.exe ... oder eine neuere Version.

    Anschließend "cmd" als Administrator ausführen und folgende Python Module installieren:

    Code
    pip install WMI win32core pypiwin32

    Dann öffnen wir zum testen die interaktive python Konsole und machen dort:

    Der nächste Schritt besteht darin diese Informationen aufzubereiten sodass sie via Socket abrufbar gemacht und im json Format verschickt werden können ....

  • Ich hab mich jetzt zunächst für folgende Struktur entschieden:

    [code=php]
    data = {
    'NVIDIA GeForce GTX 970': { # hardware.Name
    '/nvidiagpu/0/clock/0': { # sensor.Identifier
    'Type': 'Clock', # sensor.SensorType
    'Name': 'GPU Core', # sensor.Name
    'Max': '1303,594', # sensor.Max
    'Min': '135', # sensor.Min
    'Value': '202,5', # sensor.Value
    },
    '/nvidiagpu/0/clock/1': { # sensor.Identifier
    'Type': 'Clock', # sensor.SensorType
    'Name': 'GPU Memory', # sensor.Name
    'Max': '3505,5', # sensor.Max
    'Min': '324', # sensor.Min
    'Value': '324', # sensor.Value
    },
    },
    'Intel Core i7-6700': {
    '/intelcpu/0/load/0': {
    'Type': 'Load',
    'Name': 'CPU Total',
    'Max': '69,20731',
    'Min': '0',
    'Value': '10,76923',
    },
    '/intelcpu/0/temperature/0': {
    'Type': 'Temperature',
    'Name': 'CPU Core #1',
    'Max': '54',
    'Min': '23',
    'Value': '29',
    },
    },
    #...
    }
    [/php]

    Erzeugt wird das wie folgt:
    [code=php]
    import wmi
    from pprint import pprint

    hwmon = wmi.WMI(namespace="root\OpenHardwareMonitor")
    hardwares = hwmon.Hardware()
    sensors = hwmon.Sensor()

    hardware_nodes = dict()
    for hardware in hardwares:
    #pprint(vars(hardware))
    if hardware.Parent == "":
    hardware_nodes[hardware.Identifier] = [hardware.Identifier]

    for hardware in hardwares:
    if hardware.Parent != "":
    hardware_nodes[hardware.Parent].append(hardware.Identifier)

    data = dict()
    for key, nodelist in hardware_nodes.items():
    for index, node in enumerate(nodelist):
    for hardware in hardwares:
    if hardware.Identifier == nodelist[index]:
    node_Name = hardware.Name
    data[node_Name] = dict()
    for sensor in sensors:
    if sensor.Parent == nodelist[index]:
    #print("[{}] ({}) {}: {}".format(node_Name, sensor.SensorType, sensor.Name, sensor.Value))
    data[node_Name][sensor.Identifier] = dict()
    data[node_Name][sensor.Identifier].update(Name=sensor.Name)
    data[node_Name][sensor.Identifier].update(Type=sensor.SensorType)
    data[node_Name][sensor.Identifier].update(Max=sensor.Max)
    data[node_Name][sensor.Identifier].update(Min=sensor.Min)
    data[node_Name][sensor.Identifier].update(Value=sensor.Value)

    #EOF
    [/php]

    Unter Zuhilfenahme von 'pprint' sieht der Inhalt von 'data' dann so aus:
    [code=php]
    >>> pprint(data)
    {'ASUS MAXIMUS VIII RANGER': {},
    'Generic Hard Disk': {'/hdd/2/load/0': {'Max': 34.75965881347656,
    'Min': 34.75965881347656,
    'Name': 'Used Space',
    'Type': 'Load',
    'Value': 34.75965881347656}},
    'Generic Memory': {'/ram/data/0': {'Max': 12.681438446044922,
    'Min': 7.818874359130859,
    'Name': 'Used Memory',
    'Type': 'Data',
    'Value': 8.850528717041016},
    '/ram/data/1': {'Max': 8.107646942138672,
    'Min': 3.2450828552246094,
    'Name': 'Available Memory',
    'Type': 'Data',
    'Value': 7.075992584228516},
    '/ram/load/0': {'Max': 79.6246566772461,
    'Min': 49.093421936035156,
    'Name': 'Memory',
    'Type': 'Load',
    'Value': 55.57101058959961}},
    'Intel Core i7-6700': {'/intelcpu/0/clock/0': {'Max': 100.25064849853516,
    'Min': 100.23233795166016,
    'Name': 'Bus Speed',
    'Type': 'Clock',
    'Value': 100.241455078125},
    '/intelcpu/0/clock/1': {'Max': 4009.662109375,
    'Min': 801.8587036132812,
    'Name': 'CPU Core #1',
    'Type': 'Clock',
    'Value': 1403.38037109375},
    '/intelcpu/0/clock/2': {'Max': 4009.660888671875,
    'Min': 801.8587036132812,
    'Name': 'CPU Core #2',
    'Type': 'Clock',
    'Value': 1403.38037109375},
    '/intelcpu/0/clock/3': {'Max': 4009.662109375,
    'Min': 801.8587036132812,
    'Name': 'CPU Core #3',
    'Type': 'Clock',
    'Value': 1403.38037109375},
    '/intelcpu/0/clock/4': {'Max': 4009.656982421875,
    'Min': 801.8587036132812,
    'Name': 'CPU Core #4',
    'Type': 'Clock',
    'Value': 1403.38037109375},
    '/intelcpu/0/load/0': {'Max': 69.20731353759766,
    'Min': 0.0,
    'Name': 'CPU Total',
    'Type': 'Load',
    'Value': 11.730766296386719},
    '/intelcpu/0/load/1': {'Max': 69.73684692382812,
    'Min': 0.0,
    'Name': 'CPU Core #1',
    'Type': 'Load',
    'Value': 14.615381240844727},
    '/intelcpu/0/load/2': {'Max': 69.51219177246094,
    'Min': 0.0,
    'Name': 'CPU Core #2',
    'Type': 'Load',
    'Value': 11.538457870483398},
    '/intelcpu/0/load/3': {'Max': 68.29268646240234,
    'Min': 0.0,
    'Name': 'CPU Core #3',
    'Type': 'Load',
    'Value': 8.46153450012207},
    '/intelcpu/0/load/4': {'Max': 70.73170471191406,
    'Min': 0.0,
    'Name': 'CPU Core #4',
    'Type': 'Load',
    'Value': 12.30769157409668},
    '/intelcpu/0/power/0': {'Max': 205536.15625,
    'Min': 0.276136577129364,
    'Name': 'CPU Package',
    'Type': 'Power',
    'Value': 7.009059429168701},
    '/intelcpu/0/power/1': {'Max': 51040.99609375,
    'Min': 0.17073291540145874,
    'Name': 'CPU Cores',
    'Type': 'Power',
    'Value': 3.5077579021453857},
    '/intelcpu/0/power/2': {'Max': 0.0,
    'Min': 0.0,
    'Name': 'CPU Graphics',
    'Type': 'Power',
    'Value': 0.0},
    '/intelcpu/0/power/3': {'Max': 38464.8359375,
    'Min': 0.019010119140148163,
    'Name': 'CPU DRAM',
    'Type': 'Power',
    'Value': 1.1168057918548584},
    '/intelcpu/0/temperature/0': {'Max': 54.0,
    'Min': 23.0,
    'Name': 'CPU Core #1',
    'Type': 'Temperature',
    'Value': 30.0},
    '/intelcpu/0/temperature/1': {'Max': 56.0,
    'Min': 23.0,
    'Name': 'CPU Core #2',
    'Type': 'Temperature',
    'Value': 29.0},
    '/intelcpu/0/temperature/2': {'Max': 50.0,
    'Min': 21.0,
    'Name': 'CPU Core #3',
    'Type': 'Temperature',
    'Value': 26.0},
    '/intelcpu/0/temperature/3': {'Max': 47.0,
    'Min': 21.0,
    'Name': 'CPU Core #4',
    'Type': 'Temperature',
    'Value': 26.0},
    '/intelcpu/0/temperature/4': {'Max': 56.0,
    'Min': 25.0,
    'Name': 'CPU Package',
    'Type': 'Temperature',
    'Value': 29.0}},
    'NVIDIA GeForce GTX 970': {'/nvidiagpu/0/clock/0': {'Max': 1303.593505859375,
    'Min': 135.0,
    'Name': 'GPU Core',
    'Type': 'Clock',
    'Value': 1113.75},
    '/nvidiagpu/0/clock/1': {'Max': 3505.500244140625,
    'Min': 324.0000305175781,
    'Name': 'GPU Memory',
    'Type': 'Clock',
    'Value': 3505.500244140625},
    '/nvidiagpu/0/clock/2': {'Max': 2607.18701171875,
    'Min': 270.0,
    'Name': 'GPU Shader',
    'Type': 'Clock',
    'Value': 2227.5},
    '/nvidiagpu/0/control/0': {'Max': 36.0,
    'Min': 0.0,
    'Name': 'GPU Fan',
    'Type': 'Control',
    'Value': 0.0},
    '/nvidiagpu/0/fan/0': {'Max': 980.0,
    'Min': 0.0,
    'Name': 'GPU',
    'Type': 'Fan',
    'Value': 0.0},
    '/nvidiagpu/0/load/0': {'Max': 90.0,
    'Min': 0.0,
    'Name': 'GPU Core',
    'Type': 'Load',
    'Value': 5.0},
    '/nvidiagpu/0/load/1': {'Max': 59.0,
    'Min': 0.0,
    'Name': 'GPU Memory '
    'Controller',
    'Type': 'Load',
    'Value': 2.0},
    '/nvidiagpu/0/load/2': {'Max': 25.0,
    'Min': 0.0,
    'Name': 'GPU Video Engine',
    'Type': 'Load',
    'Value': 0.0},
    '/nvidiagpu/0/load/3': {'Max': 28.31249237060547,
    'Min': 2.142333984375,
    'Name': 'GPU Memory',
    'Type': 'Load',
    'Value': 14.428234100341797},
    '/nvidiagpu/0/smalldata/1': {'Max': 4008.25,
    'Min': 2936.3203125,
    'Name': 'GPU Memory '
    'Free',
    'Type': 'SmallData',
    'Value': 3505.01953125},
    '/nvidiagpu/0/smalldata/2': {'Max': 1159.6796875,
    'Min': 87.75,
    'Name': 'GPU Memory '
    'Used',
    'Type': 'SmallData',
    'Value': 590.98046875},

    '/nvidiagpu/0/smalldata/3': {'Max': 4096.0,
    'Min': 4096.0,
    'Name': 'GPU Memory '
    'Total',
    'Type': 'SmallData',
    'Value': 4096.0},
    '/nvidiagpu/0/temperature/0': {'Max': 62.0,
    'Min': 42.0,
    'Name': 'GPU Core',
    'Type': 'Temperature',
    'Value': 58.0}},
    'Samsung SSD 850 EVO 250GB': {'/hdd/0/data/0': {'Max': 670.562255859375,
    'Min': 616.9454956054688,
    'Name': 'Total LBA Written',
    'Type': 'Data',
    'Value': 670.562255859375},
    '/hdd/0/load/0': {'Max': 47.941497802734375,
    'Min': 47.87434387207031,
    'Name': 'Used Space',
    'Type': 'Load',
    'Value': 47.899600982666016},
    '/hdd/0/temperature/0': {'Max': 42.0,
    'Min': 33.0,
    'Name': 'Temperature',
    'Type': 'Temperature',
    'Value': 37.0}},
    'WDC WD10EFRX-68PJCN0': {'/hdd/1/load/0': {'Max': 94.90141296386719,
    'Min': 93.27147674560547,
    'Name': 'Used Space',
    'Type': 'Load',
    'Value': 94.54857635498047},
    '/hdd/1/temperature/0': {'Max': 34.0,
    'Min': 29.0,
    'Name': 'Temperature',
    'Type': 'Temperature',
    'Value': 32.0}}}
    >>>
    [/php]

    Gezieltes abrufen von zB meiner GPU:
    [code=php]
    >>> pprint(data['NVIDIA GeForce GTX 970'])
    {'/nvidiagpu/0/clock/0': {'Max': 1303.593505859375,
    'Min': 135.0,
    'Name': 'GPU Core',
    'Type': 'Clock',
    'Value': 1113.75},
    '/nvidiagpu/0/clock/1': {'Max': 3505.500244140625,
    'Min': 324.0000305175781,
    'Name': 'GPU Memory',
    'Type': 'Clock',
    'Value': 3505.500244140625},
    '/nvidiagpu/0/clock/2': {'Max': 2607.18701171875,
    'Min': 270.0,
    'Name': 'GPU Shader',
    'Type': 'Clock',
    'Value': 2227.5},
    '/nvidiagpu/0/control/0': {'Max': 36.0,
    'Min': 0.0,
    'Name': 'GPU Fan',
    'Type': 'Control',
    'Value': 0.0},
    '/nvidiagpu/0/fan/0': {'Max': 980.0,
    'Min': 0.0,
    'Name': 'GPU',
    'Type': 'Fan',
    'Value': 0.0},
    '/nvidiagpu/0/load/0': {'Max': 90.0,
    'Min': 0.0,
    'Name': 'GPU Core',
    'Type': 'Load',
    'Value': 5.0},
    '/nvidiagpu/0/load/1': {'Max': 59.0,
    'Min': 0.0,
    'Name': 'GPU Memory Controller',
    'Type': 'Load',
    'Value': 2.0},
    '/nvidiagpu/0/load/2': {'Max': 25.0,
    'Min': 0.0,
    'Name': 'GPU Video Engine',
    'Type': 'Load',
    'Value': 0.0},
    '/nvidiagpu/0/load/3': {'Max': 28.31249237060547,
    'Min': 2.142333984375,
    'Name': 'GPU Memory',
    'Type': 'Load',
    'Value': 14.428234100341797},
    '/nvidiagpu/0/smalldata/1': {'Max': 4008.25,
    'Min': 2936.3203125,
    'Name': 'GPU Memory Free',
    'Type': 'SmallData',
    'Value': 3505.01953125},
    '/nvidiagpu/0/smalldata/2': {'Max': 1159.6796875,
    'Min': 87.75,
    'Name': 'GPU Memory Used',
    'Type': 'SmallData',
    'Value': 590.98046875},
    '/nvidiagpu/0/smalldata/3': {'Max': 4096.0,
    'Min': 4096.0,
    'Name': 'GPU Memory Total',
    'Type': 'SmallData',
    'Value': 4096.0},
    '/nvidiagpu/0/temperature/0': {'Max': 62.0,
    'Min': 42.0,
    'Name': 'GPU Core',
    'Type': 'Temperature',
    'Value': 58.0}}
    >>>
    [/php]

    ...das müsste jetzt eigentlich genau dem entsprechen was benötigt wird, oder seh ich das falsch? :s

  • Übertragung der Daten übers Netzwerk hab ich nun auch erfolgreich bewerkstelligt. Dazu verwende ich "socketserver" der über "threading" immer wieder eine erneute Verbindung erlaubt. Desweiteren übermittel ich erst die Länge der zu übertragenen Bytes damit der Client diese gezielt abrufen/auslesen kann. Zur Übertragung muss das Dictionary erst in Json umgewandelt werden und auf der Gegenstelle dann natürlich auch wieder zurück. Es werden zZt alle Daten übermittelt, ob später noch ne gezielte Selektion kommen wird überleg ich mir später ;)

    wmi_server.py => http://codepad.org/SiQ7S9hP
    [code=php]
    #
    # Creator: meigrafd
    # Copyright (C) 2017 by meiraspi@gmail.com published under the Creative Commons License (BY-NC-SA)
    #
    # On Windows install OpenHardwareMonitor, Python >= 3.4 and:
    # pip install WMI win32core pypiwin32
    #

    import wmi
    import json
    import struct
    import threading
    import pythoncom
    import socketserver


    def hw_tree(hwmon):
    hardwares = hwmon.Hardware()
    sensors = hwmon.Sensor()
    hardware_nodes = dict()
    for hardware in hardwares:
    if hardware.Parent == "":
    hardware_nodes[hardware.Identifier] = [hardware.Identifier]

    for hardware in hardwares:
    if hardware.Parent != "":
    hardware_nodes[hardware.Parent].append(hardware.Identifier)

    data = dict()
    for key, nodelist in hardware_nodes.items():
    for index, node in enumerate(nodelist):
    for hardware in hardwares:
    if hardware.Identifier == nodelist[index]:
    node_Name = hardware.Name
    data[node_Name] = dict()
    for sensor in sensors:
    if sensor.Parent == nodelist[index]:
    data[node_Name][sensor.Identifier] = dict()
    data[node_Name][sensor.Identifier].update(Name=sensor.Name)
    data[node_Name][sensor.Identifier].update(Type=sensor.SensorType)
    data[node_Name][sensor.Identifier].update(Max=sensor.Max)
    data[node_Name][sensor.Identifier].update(Min=sensor.Min)
    data[node_Name][sensor.Identifier].update(Value=sensor.Value)

    return data


    #socket server
    class ThreadedTCPRequestHandler(socketserver.StreamRequestHandler):
    def handle(self):
    try:
    pythoncom.CoInitialize() # need this for multithreading COM/WMI
    hwmon = wmi.WMI(namespace="root\OpenHardwareMonitor")
    data = hw_tree(hwmon)
    #data = json.dumps(data, sort_keys=True, indent=4, separators=(',', ': '))
    data = json.dumps(data, sort_keys=True)
    data = data.encode()
    data_len = len(data)
    self.wfile.write(struct.pack('<L', data_len))
    self.wfile.flush()
    self.wfile.write(data)
    self.wfile.flush()
    except Exception as e2:
    print("Error in ThreadedTCPRequestHandler: " + str(e2))

    class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
    pass


    def main(SocketHost="0.0.0.0", SocketPort=7060):
    try:
    socket_server = ThreadedTCPServer((SocketHost, SocketPort), ThreadedTCPRequestHandler)
    # Start a thread with the server - that thread will then start one more thread for each request
    socket_server_thread = threading.Thread(target=socket_server.serve_forever)
    socket_server_thread.start()
    except Exception as e1:
    print("Error...: " + str(e1))
    except (KeyboardInterrupt, SystemExit):
    print("Schliesse Programm..")


    if __name__ == '__main__':
    main()

    #EOF
    [/php]

    client.py => http://codepad.org/IndgRcom
    [code=php]
    #!/usr/bin/python3
    #
    # Linux side wmi socket client
    #
    import sys
    import json
    import socket
    import struct
    from pprint import pprint

    Ziel = "192.168.0.10"
    Port = 7060

    client_socket = socket.socket()
    client_socket.settimeout(10)
    try:
    client_socket.connect((Ziel, Port))
    except (socket.timeout, ConnectionRefusedError) as Error:
    print(Error)
    sys.exit(1)
    client_socket.settimeout(None)
    connection = client_socket.makefile('rb')

    data_len = struct.unpack('<L', connection.read(struct.calcsize('<L')))[0]
    #print(data_len)
    if data_len:
    data = connection.read(data_len).decode()
    data = json.loads(data)
    pprint(data)


    connection.close()
    client_socket.close()


    #EOF
    [/php]


    Nächster Schritt: GUI zurecht zimmern


    //EDIT: Um das Python Script unter Windows im Hintergrund auszuführen: https://stackoverflow.com/a/783555/2641799

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!