{"id":839,"date":"2025-09-24T12:49:44","date_gmt":"2025-09-24T10:49:44","guid":{"rendered":"https:\/\/elv001.staging.360vier.net\/?p=839"},"modified":"2026-03-05T13:46:57","modified_gmt":"2026-03-05T12:46:57","slug":"virtuelle-instrumente-python-raspberrypi","status":"publish","type":"post","link":"https:\/\/de.elv.com\/elvjournal\/virtuelle-instrumente-python-raspberrypi\/","title":{"rendered":"Einstieg in Python (Teil 11): virtuelle Instrumente"},"content":{"rendered":"\n

Einstieg in Python, Teil 11<\/strong><\/p>\n\n\n\n

Virtuelle Instrumente<\/h1>\n\n\n\n

In einer zunehmend digitalisierten Welt spielen virtuelle Instrumente eine immer wichtigere Rolle. In Forschung, Lehre und industriellen Anwendungen sind sie praktisch \u00fcberall im Einsatz. Anstelle teurer physikalischer Messger\u00e4te erm\u00f6glichen es virtuelle Instrumente, Signale zu simulieren, Daten zu erfassen, zu analysieren und visuell darzustellen \u2013 alles direkt auf einem Computer oder sogar auf einem kleinen System wie dem Raspberry Pi. Besonders attraktiv wird dieses Konzept durch die Programmiersprache Python, die durch ihre einfache Syntax und umfangreiche Bibliotheken ideale Voraussetzungen f\u00fcr die Entwicklung solcher Softwarel\u00f6sungen bietet. <\/strong>

Ob Oszilloskope, Spektrumanalysatoren oder Temperaturmonitore \u2013 mit Python lassen sich vielseitige virtuelle Instrumente erstellen, die nicht nur kosteng\u00fcnstig, sondern auch flexibel anpassbar sind. Dieser Artikel gibt einen praxisnahen Einstieg in die Welt der virtuellen Instrumente mit Python: von der grundlegenden Idee \u00fcber geeignete Bibliotheken wie Tkinter bis hin zu konkreten Umsetzungsbeispielen.<\/strong><\/p>\n\n\n\n

Analoge Eingangssignale erfassen<\/h2>\n\n\n\n

Als leistungsf\u00e4higer Einplatinencomputer eignet sich der Raspberry Pi hervorragend f\u00fcr Mess- und Steuerungsaufgaben. Eine seiner wenigen Einschr\u00e4nkungen: Er verf\u00fcgt \u00fcber keine integrierten analogen Eing\u00e4nge. F\u00fcr Projekte, die analoge Signale \u2013 etwa von Sensoren, Potentiometern oder analogen Spannungsquellen \u2013 erfassen sollen, ist daher ein externer Analog-Digital-Wandler (ADC) notwendig.

Ein besonders kompakter und leicht zu integrierender ADC ist der MCP3002<\/a> von Microchip. Dieser 10-Bit-Konverter kommuniziert \u00fcber die SPI-Schnittstelle und bietet zwei analoge Eingangskan\u00e4le. Damit eignet er sich ideal f\u00fcr einfache Messaufgaben wie Spannungsmessung, Sensoranbindung oder Signalanalyse.

In Kombination mit Python und der spidev<\/code>-Bibliothek l\u00e4sst sich der MCP3002 schnell in Betrieb nehmen. Die Messdaten k\u00f6nnen anschlie\u00dfend f\u00fcr weitere Anwendungen genutzt werden \u2013 etwa zur Visualisierung in einem virtuellen Oszilloskop, zur Datenaufzeichnung oder zur Steuerung von Aktoren.

Im Folgenden wird kurz erl\u00e4utert, wie der ADC am Raspberry Pi eingesetzt werden kann. Weitere Details dazu wurden bereits im Artikel \u201eErfassung analoger Werte\u201c in Teil 5 dieser Reihe<\/a> vorgestellt und k\u00f6nnen dort bei Bedarf nachgeschlagen werden.

Der MCP3002 erm\u00f6glicht mit seinen zwei Eingangskan\u00e4len die pr\u00e4zise Erfassung analoger Spannungen \u2013 z.\u202fB. von Temperatur-, Licht- oder Positionssensoren. Dank seines kleinen Geh\u00e4uses, niedrigen Stromverbrauchs und der einfachen Ansteuerung ist er ideal f\u00fcr kompakte und energieeffiziente Messsysteme. Die folgende Tabelle fasst die wichtigsten Daten des Bausteins zusammen:<\/p>\n\n\n\n

Aufl\u00f6sung<\/strong><\/td>10 Bit (Wertebereich: 0\u20131023)<\/td><\/tr>
Eingangskan\u00e4le<\/strong><\/td>2 (CH0 und CH1)<\/td><\/tr>
Schnittstelle<\/strong><\/td>SPI (bis zu 3,6\u202fMHz Taktfrequenz)<\/td><\/tr>
Versorgungsspannung<\/strong><\/td>2,7\u20135,5 V<\/td><\/tr>
Abtastrate<\/strong><\/td>bis ca. 200\u202fksps (kilo-samples per second)<\/td><\/tr>
Typischer Stromverbrauch<\/strong><\/td>< 1\u202fmA aktiv, < 2\u202f\u00b5A im Stand-by<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

In Bild 1<\/mark> und Bild 2<\/mark> wird gezeigt, wie der Baustein mit dem Raspberry Pi verbunden wird.    <\/p>\n\n\n\n

\n
\n
\"Bild
Bild 1: MCP3002 am Raspberry Pi<\/figcaption><\/figure>\n<\/div>\n\n\n\n
\n
\"Bild
Bild 2: Aufbau zum ADC-Anschluss an den Raspberry Pi<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n

Die folgende Tabelle zeigt die Verbindungen im \u00dcberblick:<\/p>\n\n\n\n

MCP3002 am Raspberry Pi<\/strong><\/td><\/tr>
MCP3002<\/strong><\/td>Raspberry Pi<\/strong><\/td><\/tr>
CS <\/td>Pin 1<\/td>CS0 \u2013 GPIO 10<\/td><\/tr>
CH0 <\/td>Pin 2<\/td>Analog Input<\/td><\/tr>
CH1<\/td>Pin 3<\/td>Analog Input<\/td><\/tr>
VSS<\/sub><\/td>Pin 4<\/td>GND<\/td><\/tr>
DIN<\/td>Pin 5<\/td>MOSI \u2013 GPIO 12<\/td><\/tr>
DOUT <\/td>Pin 6<\/td>MISO \u2013 GPIO 13<\/td><\/tr>
CLK<\/td>Pin 7<\/td>SCLK \u2013 GPIO 14<\/td><\/tr>
VDD<\/sub><\/td>Pin 8<\/td>3V3<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Das folgende Programm liest den MCP3002 aus und stellt die ADC-Counts sowie die zugeh\u00f6rigen Spannungswerte auf der Konsole dar (MCP3002_tst.py):<\/p>\n\n\n\n

\nimport spidev\nimport time\n\n# SPI initialisieren\nspi = spidev.SpiDev()\nspi.open(0, 0)  # Bus 0, Device 0 (CE0)\nspi.max_speed_hz = 1000000  # 1 MHz\n\n# Referenzspannung (V_REF = 3.3V)\nV_REF = 3.3\n\n# Funktion zum Auslesen des MCP3002 (Kanal 0 oder 1)\ndef read_mcp3002(channel):\n    if channel not in [0, 1]:\n        raise ValueError(\"Kanal muss 0 oder 1 sein\")\n    # Startbit (1), Single-Ended (1), Kanal (0\/1), MSBF (1)\n    data = spi.xfer2([0b01101000 | (channel << 4), 0])\n    # Ergebnis: 10-Bit-Wert aus den empfangenen Bytes\n    adc_value = ((data[0] & 0x03) << 8) | data[1]\n    return adc_value\n\n# Spannung berechnen\ndef calculate_voltage(adc_value):\n    return (adc_value \/ 1023) * V_REF\n\n# Hauptprogramm\ntry:\n    while True:\n        # Lies ADC-Wert von Kanal 0\n        adc_value = read_mcp3002(0)\n        # Berechne Spannung\n        voltage = calculate_voltage(adc_value)\n        # Ausgabe in der Konsole\n        print(f\"ADC-Wert: {adc_value}, Spannung: {voltage:.2f} V\")\n        time.sleep(0.1)  # Aktualisiere alle 100 ms\nexcept KeyboardInterrupt:\n    print(\"\\nProgramm beendet.\")\nfinally:\n    spi.close()\n<\/code><\/pre>\n\n\n\n
Durch Anschluss eines zweiten Potentiometers (an Ch1, Pin3) k\u00f6nnen auch beide Kan\u00e4le ausgelesen werden (MCP3002_dual.py):<\/p>\n\n\n\n
\nimport<\/strong> spidev\nimport<\/strong> time\n\n# SPI initialisieren\nspi = spidev.SpiDev()\nspi.open(0, 0)  # Bus 0, Device 0 (CE0)\nspi.max_speed_hz = 1000000  # 1 MHz\n\n# Referenzspannung (V_REF = 3.3V)\nV_REF = 3.3\n\n# Funktion zum Auslesen des MCP3002 (Kanal 0 oder 1)\ndef<\/strong> read_mcp3002(channel):\n    if<\/strong> channel not<\/strong> in<\/strong> [0, 1]:\n        raise<\/strong> ValueError(\"Kanal muss 0 oder 1 sein\")\n    # Startbit (1), Single-Ended (1), Kanal (0\/1), MSBF (1)\n    data = spi.xfer2([0b01101000 | (channel << 4), 0])\n    # Ergebnis: 10-Bit-Wert aus den empfangenen Bytes\n    adc_value = ((data[0] & 0x03) << 8) | data[1]\n    return<\/strong> adc_value\n\n# Spannung berechnen\ndef<\/strong> calculate_voltage(adc_value):\n    return<\/strong> (adc_value \/ 1023) * V_REF\n\n# Hauptprogramm\ntry<\/strong>:\n    while<\/strong> True:\n        for<\/strong> channel in<\/strong> [0, 1]:\n            adc_value = read_mcp3002(channel)\n            voltage = calculate_voltage(adc_value)\n            print<\/strong>(f\"Kanal {channel}: ADC-Wert = {adc_value}, Spannung = {voltage:.2f} V\")\n        print<\/strong>(\"-\" * 40)\n        time.sleep(0.5)  # Aktualisiere alle 500 ms\nexcept<\/strong> KeyboardInterrupt:\n    print<\/strong>(\"\\nProgramm beendet.\")\nfinally<\/strong>:\n    spi.close()\n<\/code><\/pre>\n\n\n\n
Die Ausgabe auf die Konsole sieht dann beispielsweise so aus (Bild 3)<\/mark>:<\/p>\n\n\n\n
\"Bild
Bild 3: ADC-Werte in der Shell<\/figcaption><\/figure>\n\n\n\n
<\/div>\n\n\n\n
Grafische Messwertdarstellung<\/h2>\n\n\n\n
Nachdem nun analoge Messwerte erfasst werden k\u00f6nnen, sollen diese im n\u00e4chsten Schritt auf virtuellen Instrumenten dargestellt werden. Eine der einfachsten M\u00f6glichkeiten hierf\u00fcr sind sogenannte Bargraphanzeigen, auch als Balkendiagramme bekannt. Trotz ihrer Einfachheit bieten Balkendiagramme eine Reihe von Vorteilen, insbesondere wenn es darum geht, Daten klar und leicht verst\u00e4ndlich darzustellen. Die Hauptvorteile dieser Darstellungsvarianten sind:<\/p>\n\n\n\n
    \n
  • \u00dcbersichtlichkeit<\/strong>: Sie machen Unterschiede zwischen Daten schnell sichtbar, da die L\u00e4nge der Balken direkt vergleichbar ist<\/li>\n\n\n\n
  • Einfache Interpretation<\/strong>: Selbst ohne tiefgehende Kenntnisse in Statistik kann man die Informationen schnell erfassen<\/li>\n\n\n\n
  • Flexibilit\u00e4t<\/strong>: Sie eignen sich sowohl f\u00fcr absolute Werte als auch f\u00fcr Verh\u00e4ltnisse<\/li>\n\n\n\n
  • Visuelle Wirkung<\/strong>: Farben und Anordnung k\u00f6nnen genutzt werden, um Muster oder Trends hervorzuheben<\/li>\n\n\n\n
  • Geringer Platzverbrauch<\/strong>: Sie k\u00f6nnen sowohl horizontal als auch vertikal gestaltet werden, je nachdem, was f\u00fcr die Darstellung am sinnvollsten ist<\/li>\n<\/ul>\n\n\n\n
    Das folgende Programm stellt die beiden ADC-Kan\u00e4le in Form von vertikalen Balken dar (MCP3002_dualBargraph.py). Die bereits bekannten Programmteile wurden im Folgenden weggelassen; der vollst\u00e4ndige Code findet sich im Downloadpaket.<\/p>\n\n\n\n
    \nimport<\/strong> spidev\nimport<\/strong> tkinter as<\/strong> tk\n\n[...]\n\nroot = tk.Tk()\nroot.title(\"MCP3002 Bargraphanzeige\")\n\ncanvas_width = 300; canvas_height = 200; bar_width = 100; bar_spacing = 110\ncanvas = tk.Canvas(root, width=canvas_width, height=canvas_height, bg='white')\ncanvas.pack()\nbar0 = canvas.create_rectangle(50, canvas_height, 50 + bar_width, canvas_height, fill=\"green\")\nbar1 = canvas.create_rectangle(50 + bar_spacing, canvas_height, 50 + bar_spacing + bar_width, canvas_height, fill=\"blue\")\nlabel0 = canvas.create_text(100, canvas_height - 5, text=\"CH0\", font=(\"Arial\", 10))\nlabel1 = canvas.create_text(100 + bar_spacing, canvas_height - 5, text=\"CH1\", font=(\"Arial\", 10))\nvalue_text0 = canvas.create_text(100, 10, text=\"\", font=(\"Arial\", 12, \"bold\"))\nvalue_text1 = canvas.create_text(100 + bar_spacing, 10, text=\"\", font=(\"Arial\", 12, \"bold\"))\n\ndef<\/strong> update_bars():\n    value0 = read_mcp3002(0); value1 = read_mcp3002(1)\n    height0 = int((value0 \/ max_adc) * (canvas_height - 40))\n    height1 = int((value1 \/ max_adc) * (canvas_height - 40))\n    canvas.coords(bar0, 50, canvas_height - height0 - 20, 50 + bar_width, canvas_height - 20)\n    canvas.coords(bar1, 50 + bar_spacing, canvas_height - height1 - 20, 50 + bar_spacing + bar_width, canvas_height - 20)\n    voltage0 = value0 * V_REF \/ max_adc; voltage1 = value1 * V_REF \/ max_adc\n    canvas.coords(value_text0, 100, canvas_height - height0 - 30)\n    canvas.itemconfig(value_text0, text=f\"{voltage0:.2f} V\")\n    canvas.coords(value_text1, 100 + bar_spacing, canvas_height - height1 - 30)\n    canvas.itemconfig(value_text1, text=f\"{voltage1:.2f} V\")\n    root.after(200, update_bars)\n\nupdate_bars()\nroot.mainloop()\nspi.close()\n<\/code><\/pre>\n\n\n\n
    \n
    \n
    Nach dem Start des Programms erscheinen die aktuellen Spannungswerte beider ADC-Kan\u00e4le in jeweils einer eigenen Balkendarstellung (Bild 4)<\/mark>. \u00dcber den Balken werden zus\u00e4tzlich die exakten Werte in numerischer Form ausgegeben.                                                                                                    <\/p>\n<\/div>\n\n\n\n
    \n
    \"Bild
    Bild 4: Bargraphanzeige der ADC-Werte<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
    Virtuelle Instrumente in allen Formen und Farben<\/h2>\n\n\n\n
    Rundinstrumente, wie sie h\u00e4ufig in Fahrzeugen, Maschinen und Uhren verwendet werden, bieten gegen\u00fcber Bargraphanzeigen einige praktische Vorteile:<\/p>\n\n\n\n
      \n
    • Schnelle Ablesbarkeit<\/strong>: Der Zeiger zeigt intuitiv auf den Wert, wodurch Informationen leicht erfasst werden k\u00f6nnen<\/li>\n\n\n\n
    • Gute Wahrnehmung bei Bewegung<\/strong>: Besonders in Autos oder Flugzeugen ist es einfacher, Ver\u00e4nderungen eines Zeigers zu erfassen als kleine digitale Zahlen<\/li>\n\n\n\n
    • \u00c4sthetik und Design<\/strong>: Runde Anzeigen wirken oft klassisch und hochwertig, weshalb sie in vielen Premium-Produkten eingesetzt werden<\/li>\n\n\n\n
    • Einfache Skalierung<\/strong>: Die Kreisform erm\u00f6glicht eine nat\u00fcrliche Verteilung von Skalenwerten, die in einem Blickfeld erfassbar sind<\/li>\n<\/ul>\n\n\n\n
      \n
      \n
      Auch Rundinstrumente (Bild 5)<\/mark> k\u00f6nnen relativ einfach in der virtuellen Welt dargestellt werden, wenngleich ihre Programmierung etwas aufwendiger ist als die Darstellung von Balkendiagrammen. Das folgende Programm (MCP3002_VirtualAnalog.py) zeigt die am ADC-Kanal 0 anliegende Spannung in einem Rundinstrument an:<\/p>\n<\/div>\n\n\n\n
      \n
      \"Bild
      Bild 5: Rundinstrument f\u00fcr den Raspberry Pi<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
      \nimport spidev, time, math, time<\/strong>\nimport<\/strong> tkinter as<\/strong> tk\nfrom<\/strong> threading import<\/strong> Thread\n\n[...]\n\nclass<\/strong> AnalogInstrument(tk.Tk):\n  def<\/strong> __init__(self):\n        super().__init__()\n        self.title(\"MCP3002 Voltmeter\")\n        self.geometry(\"400x450\")\n        self.canvas = tk.Canvas(self, width=400, height=450, bg=\"#000000\")\n        self.canvas.pack()\n        self.canvas.create_oval(50, 50, 350, 350, outline=\"#00008B\", fill=\"#00008B\", width=2)\n        for<\/strong> i in<\/strong> range(0, 271, 27):\n            angle = math.radians(i - 135 + 270)\n            x1 = 200 + math.cos(angle) * 120\n            y1 = 200 + math.sin(angle) * 120\n            x2 = 200 + math.cos(angle) * 140\n            y2 = 200 + math.sin(angle) * 140\n            self.canvas.create_line(x1, y1, x2, y2, fill=\"#00FF00\")\n\n            label_x = 200 + math.cos(angle) * 170\n            label_y = 200 + math.sin(angle) * 170\n            label_value = round(i * 5.0 \/ 270, 2)  # Spannung berechnen\n            self.canvas.create_text(label_x, label_y, text=str(label_value), font=(\"Arial\", 16), fill=\"#00FF00\")\n\n        self.pointer = self.canvas.create_line(200, 200, 200, 80, fill=\"#FF4500\", width=4)\n        self.voltage_label = self.canvas.create_text(200, 400, text=\"Spannung: 0 V\", font=(\"Arial\", 20), fill=\"#00FF00\")\n\n        self.running = True\n        self.thread = Thread(target=self.update_instrument)\n        self.thread.daemon = True\n        self.thread.start()\n\n    def<\/strong> update_instrument(self):\n        while<\/strong> self.running:\n            try<\/strong>:\n                voltage = read_mcp3002(0)\n                angle = (voltage \/ 5.0) * 270 - 135 + 270\n                angle_rad = math.radians(angle)\n                x = 200 + math.cos(angle_rad) * 110\n                y = 200 + math.sin(angle_rad) * 110\n                self.canvas.coords(self.pointer, 200, 200, x, y)\n                self.canvas.itemconfig(self.voltage_label, text=f\"Spannung: {voltage:.2f} V\")\n                time.sleep(0.1)\n            except<\/strong> Exception as<\/strong> e:\n                print<\/strong>(f\"Fehler: {e}\")\n                break<\/strong>\n\n    def<\/strong> destroy(self):\n        self.running = False\n        spi.close()\n        super().destroy()\n\n# Hauptprogramm\napp = AnalogInstrument()\napp.mainloop()\n<\/code><\/pre>\n\n\n\n
      Das Programm emuliert ein einfaches analoges Voltmeter, das die Messwerte eines MCP3002-AD-Wandlers grafisch als Rundinstrumenten-Anzeige darstellt.
      Die Klasse AnalogInstrument erstellt eine grafische Oberfl\u00e4che mit Tkinter. Das Voltmeter besteht dabei aus den folgenden Elementen:<\/p>\n\n\n\n
        \n
      • Ziffernblatt mit Skala (0\u20135 V)<\/li>\n\n\n\n
      • Zeiger<\/li>\n\n\n\n
      • Numerische Anzeige der Spannung<\/li>\n<\/ul>\n\n\n\n
        F\u00fcr eine fl\u00fcssige Darstellung wird ein eigener Thread (self.thread) gestartet, um die Spannung kontinuierlich zu messen und die Anzeige zu aktualisieren. Der Zeiger wird dann entsprechend der gemessenen Spannung dargestellt. Die Spannung wird in einen Winkel (0\u2013270\u00b0) umgerechnet, und die Koordinaten des Zeigers werden mit self.canvas.coords() berechnet. Das Programm l\u00e4uft in einer Endlosschleife, bis die GUI geschlossen wird. Danach wird die SPI-Schnittstelle sauber beendet.<\/p>\n\n\n\n
        \n
        \n
        Man kann sogar noch einen Schritt weiter gehen und ein klassisches Analoginstrument virtualisieren. Bild 6<\/mark> zeigt eine entsprechende Darstellung. Da das Programm hierf\u00fcr bereits relativ umfangreich ist, soll es hier nicht im Detail wiedergegeben und diskutiert werden. Der vollst\u00e4ndige Code findet sich aber im Downloadpaket.<\/p>\n<\/div>\n\n\n\n
        \n
        \"Bild
        Bild 6: Virtuelles analoges Voltmeter<\/figcaption><\/figure>\n<\/div>\n<\/div>\n\n\n\n
        Ein besonderer Vorteil bei virtuellen Instrumenten ist, dass der exakte Wert zus\u00e4tzlich auch digital dargestellt werden kann. Damit werden Ablesefehler nahezu ausgeschlossen.<\/p>\n\n\n\n
        Wetter- und Klimadaten aus dem Internet<\/h2>\n\n\n\n
        Auch ohne AD-Wandler k\u00f6nnen virtuelle Instrumente nutzbringend eingesetzt werden. Eine M\u00f6glichkeit ist die Verwendung von aktuellen Wetterdaten aus dem Internet. Damit lassen sich individuelle Klimastationen aufbauen, ohne dass aufwendige Sensoren auf der Anwenderseite erforderlich sind. 

        Die Wetterdaten k\u00f6nnen von OpenWeatherMap auf den Raspberry Pi geladen werden, indem eine API genutzt wird. Hier sind die grundlegenden Schritte:<\/p>\n\n\n\n
          \n
        • Auf OpenWeatherMap registrieren und einen kostenlosen API-Schl\u00fcssel erstellen<\/li>\n\n\n\n
        • requests<\/strong> installieren, um HTTP-Anfragen zu senden:<\/li>\n<\/ul>\n\n\n\n
          pip install requests\n<\/code><\/pre>\n\n\n\n
          Dann k\u00f6nnen verschiedene Wetterdaten ausgelesen und dargestellt werden (OpenWeatherMap_tst.py)<\/p>\n\n\n\n
          \nimport requests\n\n# API-Schl\u00fcssel und Stadt\nAPI_KEY = \"12345678901234567890123456789012\"\nSTADT = \"Leer\"\nURL = f\"http:\/\/api.openweathermap.org\/data\/2.5\/weather?q={STADT}&appid={API_KEY}&units=metric\"\n\n# Wetterdaten abrufen\nresponse = requests.get(URL)\nwetterdaten = response.json()\n\n# Daten extrahieren\ntemperatur = f\"{wetterdaten['main']['temp']} \u00b0C\"\nluftfeuchtigkeit = f\"{wetterdaten['main']['humidity']} %\"\nluftdruck = f\"{wetterdaten['main']['pressure']} hPa\"\nwindgeschwindigkeit = f\"{wetterdaten['wind']['speed']} m\/s\"\nwetterlage = wetterdaten['weather'][0]['description']\n\n# Formatierte Ausgabe\nprint(\"=\"*30)\nprint(f\"{'Parameter':<20}{'Wert':<10}\")\nprint(\"=\"*30)\nprint(f\"{'Temperatur':<20}{temperatur:<10}\")\nprint(f\"{'Luftfeuchtigkeit':<20}{luftfeuchtigkeit:<10}\")\nprint(f\"{'Luftdruck':<20}{luftdruck:<10}\")\nprint(f\"{'Windgeschwindigkeit':<20}{windgeschwindigkeit:<10}\")\nprint(f\"{'Wetterlage':<20}{wetterlage:<10}\")\nprint(\"=\"*30)\n<\/code><\/pre>\n\n\n\n
          Bild 7<\/mark> zeigt ein beispielhaftes Ergebnis dieser Abfrage.<\/p>\n\n\n\n
          \"Bild
          Bild 7: Wetter und Klimadaten aus dem Internet<\/figcaption><\/figure>\n\n\n\n
          Im Folgenden soll gezeigt werden, wie diese Daten f\u00fcr einer ansprechenden Wetterstation umgesetzt werden k\u00f6nnen.<\/p>\n\n\n\n
          Umfangreiche virtuelle Klimastation<\/strong><\/h2>\n\n\n\n
          Eine virtuelle Wetterstation auf dem Raspberry Pi bietet zahlreiche praktische Vorteile, die sie zu einer idealen L\u00f6sung f\u00fcr private und p\u00e4dagogische Zwecke machen. Der gr\u00f6\u00dfte Pluspunkt ist die Kosteneffizienz \u2013 im Gegensatz zu teuren professionellen Wetterstationen gen\u00fcgen hier ein preiswerter Raspberry Pi und ein einfaches Display. Auf kostspielige Spezialsensoren kann verzichtet werden, da die Wetterdaten direkt von der OpenWeatherMap API bezogen werden.

          Die Station ist platzsparend und mobil einsetzbar, sei es in der Wohnung, im B\u00fcro oder in einem Klassenzimmer. Anders als bei analogen Wetterstationen gibt es keine mechanischen Bauteile, die verschlei\u00dfen k\u00f6nnten, was die Wartung vereinfacht. Updates erfolgen rein softwarebasiert, und Messbereiche lassen sich problemlos per Code anpassen, ohne dass Hardware ausgetauscht werden m\u00fcsste.

          Die Erweiterbarkeit ist ebenfalls ein gro\u00dfer Vorteil: Nutzer k\u00f6nnen die Anzeige individuell anpassen, zus\u00e4tzliche Wetterparameter einbinden oder die Visualisierung f\u00fcr verschiedene Displaygr\u00f6\u00dfen skalieren. Zudem lassen sich \u201eSmart Features\u201c wie<\/p>\n\n\n\n
            \n
          • automatische Datenaktualisierungen,<\/li>\n\n\n\n
          • historische Datenspeicherung oder<\/li>\n\n\n\n
          • Warnmeldungen bei Extremwerten<\/li>\n<\/ul>\n\n\n\n
            implementieren.

            Die Wetterstation (OpenWeatherMap_graph.py) zeigt die aktuellen Wetterdaten und Vorhersagen f\u00fcr einen konfigurierbaren Ort (z. B. Leer, Hamburg oder M\u00fcnchen) an. Das Programm nutzt die OpenWeatherMap API, um Echtzeit-Wetterinformationen abzurufen und in einer ansprechenden Visualisierung darzustellen.<\/strong> Die Anwendung besteht aus vier Hauptinstrumenten:<\/p>\n\n\n\n
              \n
            • Thermometer mit einem Messbereich von -20 \u00b0C bis +40 \u00b0C,<\/li>\n\n\n\n
            • Hygrometer f\u00fcr die Luftfeuchtigkeit von 0 bis 100 %,<\/li>\n\n\n\n
            • Barometer f\u00fcr den Luftdruck (950\u20131050 hPa)<\/li>\n\n\n\n
            • Windrose sowie Bargraphanzeige zur Darstellung von Windrichtung und -geschwindigkeit (0\u2013100 km\/h).<\/li>\n<\/ul>\n\n\n\n
              Da das Programm recht umfangreich ist, soll es hier nicht vollst\u00e4ndig angegeben werden (die komplette Version findet sich im Downloadpaket). Vielmehr sollen exemplarisch einige wichtige Details n\u00e4her erl\u00e4utert werden. 

              Das Dashboard liefert das Grundger\u00fcst f\u00fcr die grafische Anzeige:<\/p>\n\n\n\n
              \nclass WeatherDashboard(tk.Tk):\n    def __init__(self):\n        super().__init__()\n        self.title(\"Virtuelle Wetterstation\")\n        self.geometry(\"1250x800\")\n        self.config(bg=BackroundColor)\n\n        main_frame = tk.Frame(self, bg=BackroundColor)\n        main_frame.pack(expand=True, fill=tk.BOTH, padx=20, pady=20)\n\n        left_frame = tk.Frame(main_frame, bg=BackroundColor)\n        left_frame.grid(row=0, column=0, padx=10, pady=10, sticky=\"n\")\n\n        center_frame = tk.Frame(main_frame, bg=BackroundColor)\n        center_frame.grid(row=0, column=1, padx=10, pady=10, sticky=\"n\")\n\n        right_frame = tk.Frame(main_frame, bg=BackroundColor)\n        right_frame.grid(row=0, column=2, padx=10, pady=10, sticky=\"n\")\n\n        # Linke Spalte\n        self.weather_icon_frame = tk.Frame(left_frame, bg=BackroundColor)\n        self.weather_icon_frame.pack()\n        self.weather_icon_label = tk.Label(self.weather_icon_frame, bg=BackroundColor)\n        self.weather_icon_label.pack()\n        self.weather_desc_label = tk.Label(left_frame, text=\"Aktuelles Wetter: -\", font=(\"Arial\", 14, \"bold\"), bg=BackroundColor)\n        self.weather_desc_label.pack(pady=5)\n        \n        self.frame_temp = tk.Frame(left_frame, bg=BackroundColor)\n        self.frame_temp.pack(pady=20)\n        self.temp_label = tk.Label(self.frame_temp, text=\"Temperatur: 0\u00b0C\", font=(\"Arial\", 14, \"bold\"), bg=BackroundColor)\n        self.temp_label.pack()\n        self.canvas_temp = tk.Canvas(self.frame_temp, width=200, height=400, bg=InstrumentBackground, highlightthickness=0)\n        self.canvas_temp.pack()\n\n        # Mittlere Spalte\n        self.frame_baro = tk.Frame(center_frame, bg=BackroundColor)\n        self.frame_baro.pack()\n        self.baro_label = tk.Label(self.frame_baro, text=\"Luftdruck: 0 hPa\", font=(\"Arial\", 14, \"bold\"), bg=BackroundColor)\n        self.baro_label.pack()\n        self.canvas_baro = tk.Canvas(self.frame_baro, width=300, height=300, bg=InstrumentBackground, highlightthickness=0)\n        self.canvas_baro.pack()\n        \n        self.frame_wind = tk.Frame(center_frame, bg=BackroundColor)\n        self.frame_wind.pack(pady=20)\n        self.wind_label = tk.Label(self.frame_wind, text=\"Wind: N (0\u00b0) - 0 km\/h\", font=(\"Arial\", 14, \"bold\"), bg=BackroundColor)\n        self.wind_label.pack()\n        self.canvas_wind = tk.Canvas(self.frame_wind, width=300, height=300, bg=InstrumentBackground, highlightthickness=0)\n        self.canvas_wind.pack()\n\n[...]\n<\/code><\/pre>\n\n\n\n
              Das Thermometer wird als stilisierte Quecksilbers\u00e4ule angezeigt:<\/p>\n\n\n\n
              \ndef draw_thermometer(self):\n        self.canvas_temp.create_rectangle(80, 30, 120, 350, outline=\"black\", width=2)\n        self.canvas_temp.create_oval(80, 330, 120, 390, outline=\"black\", width=2, fill=\"red\")\n        for i in range(-20, 41, 5):\n            y = 350 - ((i + 20) * 5)\n            self.canvas_temp.create_line(120, y, 140, y, fill=\"black\", width=2)\n            self.canvas_temp.create_text(150, y, text=f\"{i}\u00b0C\", font=(\"Arial\", 10), anchor=\"w\", fill=\"blue\")\n        self.mercury = self.canvas_temp.create_rectangle(81, 350, 119, 350, fill=\"red\")\n<\/code><\/pre>\n\n\n\n
              Luftdruckanzeige und Hygrometer bestehen aus einem Rundinstrument:<\/p>\n\n\n\n
              \ndef draw_hygrometer(self):\n        self.canvas_humidity.create_oval(50, 50, 350, 350, outline=\"black\", width=1, fill=InstrumentColor)\n        for i in range(0, 101, 10):\n            angle = math.radians((i \/ 100) * 270 - 135 + 270)\n            x1 = 200 + math.cos(angle) * 120\n            y1 = 200 + math.sin(angle) * 120\n            x2 = 200 + math.cos(angle) * 140\n            y2 = 200 + math.sin(angle) * 140\n            self.canvas_humidity.create_line(x1, y1, x2, y2, fill=\"blue\", width=2)\n            label_x = 200 + math.cos(angle) * 100\n            label_y = 200 + math.sin(angle) * 100\n            self.canvas_humidity.create_text(label_x, label_y, text=f\"{i}%\", font=(\"Arial\", 12, \"bold\"), fill=\"blue\")\n        self.pointer = self.canvas_humidity.create_line(200, 200, 200, 80, fill=\"red\", width=4)\n<\/code><\/pre>\n\n\n\n
              Die Wettervorhersage wird als f\u00fcnfzeiliger Text ausgegeben:<\/p>\n\n\n\n
              \ndef update_forecast(self, forecast_data):\n        weekdays_de = [\"Mo\", \"Di\", \"Mi\", \"Do\", \"Fr\", \"Sa\", \"So\"]\n        daily_forecasts = {}\n        for forecast in forecast_data['list']:\n            date = forecast['dt_txt'].split()[0]\n            if date not in daily_forecasts:\n                daily_forecasts[date] = []\n            daily_forecasts[date].append(forecast)\n        forecast_dates = sorted(daily_forecasts.keys())[:5]\n        for i, date in enumerate(forecast_dates):\n            day_forecast = None\n            for forecast in daily_forecasts[date]:\n                if forecast['dt_txt'].endswith(\"12:00:00\"):\n                    day_forecast = forecast\n                    break\n            if not day_forecast:\n                day_forecast = daily_forecasts[date][len(daily_forecasts[date])\/\/2]\n            temp_max = max(f['main']['temp_max'] for f in daily_forecasts[date])\n            temp_min = min(f['main']['temp_min'] for f in daily_forecasts[date])\n            description = day_forecast['weather'][0]['description'].capitalize()\n            weekday_num = time.strptime(date, \"%Y-%m-%d\").tm_wday\n            weekday = weekdays_de[weekday_num]\n            forecast_text = (f\"{weekday} ({date[8:10]}.{date[5:7]}): \"\n                             f\"{description}, {day_forecast['main']['temp']:.1f}\u00b0C \"\n                             f\"(max {temp_max:.1f}\u00b0C, min {temp_min:.1f}\u00b0C), \"\n                             f\"Wind: {day_forecast['wind']['speed']*3.6:.1f} km\/h\")\n            if i < len(self.forecast_labels):\n                self.forecast_labels[i].config(text=forecast_text)\n\n<\/code><\/pre>\n\n\n\n
              Die Vorhersage erfolgt mit deutschen Wochentagen und gibt die erwartete Wetterentwicklung an.

              Das Programm nutzt Tkinter f\u00fcr die GUI-Entwicklung und verwendet die Bibliotheken \u201erequests\u201c f\u00fcr den API-Zugriff, sowie \u201ethreading\u201c f\u00fcr die regelm\u00e4\u00dfige Aktualisierung der Daten im Hintergrund. Die Aktualisierung erfolgt alle zehn Minuten, bei Fehlern wird ein k\u00fcrzeres Intervall verwendet.

              Besondere Merkmale sind die freie Farbgestaltung, die pr\u00e4zise Skalierung aller Anzeigeinstrumente und die deutschsprachige Oberfl\u00e4che. Die Windrose verf\u00fcgt \u00fcber einen stilisierten Zeiger, w\u00e4hrend das Barometer eine klare Druckanzeige mit skalierter Anzeige bietet. 

              Das Programm (Bild 8)<\/mark> startet mit einem Fenster der Gr\u00f6\u00dfe 1250 x 800 Pixel und ist in drei Spalten unterteilt: Links befinden sich Thermometer und Wettergrafik, in der Mitte Barometer und Windrose, rechts Hygrometer, Windgeschwindigkeit und die f\u00fcnft\u00e4gige Vorhersage. Alle Instrumente sind klar beschriftet und zeigen die Werte sowohl grafisch als auch numerisch an.<\/p>\n\n\n\n
              \"Bild
              Bild 8: Virtuelle Klimastation<\/figcaption><\/figure>\n\n\n\n
              <\/div>\n\n\n\n
              \n
              Erg\u00e4nzungen und Anregungen<\/strong><\/h2>\n\n\n\n
                \n
              • Wie kann man Stromst\u00e4rken mit einem virtuellen Instrument anzeigen?<\/li>\n\n\n\n
              • Kann man die Instrumente nach Bild 5<\/mark> oder Bild 6<\/mark> auch mit Autoscaling-Funktionen versehen?<\/li>\n\n\n\n
              • K\u00f6nnte man auch reale Sensoren f\u00fcr Luftdruck und -feuchtigkeit auf virtuellen Analoguhr-Instrumenten ausgeben?\n
                  \n
                • Wie k\u00f6nnten diese Instrumente aussehen?<\/li>\n\n\n\n
                • Kann man die Instrumente auch durch animierte Grafiken darstellen?<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                • Wie kann man die Wetterstation um historische Verl\u00e4ufe von Temperatur, Feuchtigkeit oder Luftdruckwerten erg\u00e4nzen?
                  <\/li>\n<\/ul>\n<\/div>\n\n\n\n
                  <\/div>\n\n\n\n
                  Zusammenfassung und Ausblick<\/h2>\n\n\n\n
                  In diesem Beitrag wurden die grafischen Darstellungsm\u00f6glichkeiten f\u00fcr virtuelle Instrumente ausf\u00fchrlich untersucht. Neben messtechnischen Anwendungen wie Analogvoltmetern wurde dabei auch eine vollst\u00e4ndige Klimastation implementiert. In den n\u00e4chsten Beitr\u00e4gen soll es hingegen wieder um reale Hardware-Instrumente in Form von Displays und Anzeigeeinheiten gehen. Diese k\u00f6nnen auf verschiedene Weise mit dem Raspberry Pi angesteuert werden. Auch hier stellt Python wieder eine Reihe n\u00fctzlicher Hilfsmittel zur Verf\u00fcgung. Im kommenden Blog-Beitrag soll dabei die Ansteuerung von 7-Segment-Anzeigen im Mittelpunkt stehen.<\/p>\n\n\n\n
                  Material<\/h2>\n\n\n\n
                    \n
                  • Raspberry Pi mit Netzteil<\/li>\n\n\n\n
                  • Breadboard und Jumper-Kabel<\/li>\n\n\n\n
                  • Analog-Digital-Wandler MCP3002<\/li>\n\n\n\n
                  • Kleinteile aus dem Set PAD-PRO-EXSB<\/span><\/li>\n<\/ul>\n\n\n
                    \n    
                    <\/div>\n<\/div>\n\n\n\n
                    <\/div>\n\n\n\n
                    \u00dcber den Autor
                    <\/strong>Dr. G\u00fcnter Spanner ist als Autor zu den Themen Elektronik, Sensortechnik und Mikrocontroller einem weiten Fachpublikum bekannt. Schwerpunkt seiner hauptberuflichen T\u00e4tigkeit f\u00fcr verschiedene Gro\u00dfkonzerne wie Siemens und ABB ist die Projektleitung im Bereich Entwicklung und Technologie-Management. Der Dozent fu\u0308r Physik und Elektrotechnik hat zudem zahlreiche Fachartikel und Bu\u0308cher vero\u0308ffentlicht sowie Kurse und Lernpakete erstellt.<\/p>\n","protected":false},"excerpt":{"rendered":"
                    Virtuelle Instrumente ersetzen teure Messger\u00e4te und bringen Datenanalyse direkt auf den Raspberry Pi. Dieser Beitrag zeigt, wie mit Python und dem ADC MCP3002 Oszilloskope, Bargraphanzeigen oder Wetterstationen realisiert werden \u2013 praxisnah und kosteng\u00fcnstig.<\/p>\n","protected":false},"author":5,"featured_media":864,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[34],"tags":[122,126,123,125,124],"post-author":[137],"class_list":["post-839","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python-micropython","tag-bargraphanzeige-tkinter","tag-openweathermap-klimastation","tag-raspberry-pi-mcp3002","tag-virtuelle-instrumente-python-aufbauen","tag-virtuelles-oszilloskop-python","post-author-dr-guenter-spanner"],"acf":[],"info":{"thumbnail":{"url":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/header_phyton_teil11.jpg","alt":""},"teaserImage":{"ID":2143,"id":2143,"title":"liste-beitrag_python_t11","filename":"Liste-Beitrag_python_t11.jpg","filesize":57730,"url":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11.jpg","link":"https:\/\/de.elv.com\/elvjournal\/virtuelle-instrumente-python-raspberrypi\/liste-beitrag_python_t11\/","alt":"","author":"5","description":"","caption":"","name":"liste-beitrag_python_t11","status":"inherit","uploaded_to":839,"date":"2025-09-03 15:10:04","modified":"2025-09-03 15:10:04","menu_order":0,"mime_type":"image\/jpeg","type":"image","subtype":"jpeg","icon":"https:\/\/elvjournal.elv.com\/wp-includes\/images\/media\/default.png","width":312,"height":198,"sizes":{"thumbnail":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11-250x198.jpg","thumbnail-width":250,"thumbnail-height":198,"medium":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11-300x190.jpg","medium-width":300,"medium-height":190,"medium_large":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11.jpg","medium_large-width":312,"medium_large-height":198,"large":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11.jpg","large-width":312,"large-height":198,"1536x1536":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11.jpg","1536x1536-width":312,"1536x1536-height":198,"2048x2048":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11.jpg","2048x2048-width":312,"2048x2048-height":198,"gform-image-choice-sm":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11.jpg","gform-image-choice-sm-width":300,"gform-image-choice-sm-height":190,"gform-image-choice-md":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11.jpg","gform-image-choice-md-width":312,"gform-image-choice-md-height":198,"gform-image-choice-lg":"https:\/\/elvjournal.elv.com\/wp-content\/uploads\/Liste-Beitrag_python_t11.jpg","gform-image-choice-lg-width":312,"gform-image-choice-lg-height":198}},"categories":[{"id":34,"name":"Python & MicroPython","slug":"python-micropython"}],"authors":[{"id":137,"name":"Dr. G\u00fcnter Spanner","slug":"dr-guenter-spanner"}],"document":false,"epaper":"","date":"24. September 2025","excerpt":"Virtuelle Instrumente ersetzen teure Messger\u00e4te und bringen Datenanalyse direkt auf den Raspberry Pi. Dieser Beitrag zeigt, wie mit Python und dem ADC MCP3002 Oszilloskope, Bargraphanzeigen oder Wetterstationen realisiert werden \u2013 praxisnah und kosteng\u00fcnstig."},"_links":{"self":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/839","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/comments?post=839"}],"version-history":[{"count":10,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/839\/revisions"}],"predecessor-version":[{"id":11590,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/posts\/839\/revisions\/11590"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/media\/864"}],"wp:attachment":[{"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/media?parent=839"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/categories?post=839"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/tags?post=839"},{"taxonomy":"post-author","embeddable":true,"href":"https:\/\/de.elv.com\/elvjournal\/wp-json\/wp\/v2\/post-author?post=839"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}