Korrelationswert

Ok, danke für die Erklärung. Bin auf das neue Backend gespannt.

Gucke mal, ob die Polling-Einstellungen in brickd.conf etwas verändert.

Hi Leute,

wie es der Titel schon sagt, ist mir aufgefallen, dass brickd auf einem RaspberryPi 3b mit angeschlossenem HAT Brick eine hohe CPU-Last erzeugt.

Es sind noch 6 Bricklets am HAT Brick angeschlossen, jedoch läuft kein Programm.

Anbei ein Screenshot von htop.

Im brickd.log steht nichts auffälliges (Neuverbindungen, Timeouts, etc.).

Kennt ihr das Problem oder ist es evtl ein Fehler in meinem Setup?

Software:

Kernel: 5.4.72-v7+ #1356 SMP Thu Oct 22 13:56:54 BST 2020 armv7l GNU/Linux

Brickd: 2.4.1

*Hand vor den Kopf hau*

Stimmt, vielen Dank.

Mh, das ich mir auch klar, doch ich möchte eine andere Funktionalität realisieren.

Ich habe ein 3x4 Touch Pad dabei und möchte auf einer Taste die Helligkeit legen, auf einer anderen die Farbe. Beides soll dann über den Rotary Poti geändert werden können. Wenn ich aber auf der Taste nur die get_position() habe, muss ich erst drehen, dann wieder auf die Taste drücken, wieder drehen...

Deshalb wäre es praktisch, wenn cb_position neue Werte bekommt (wenn der Rotary Poti gedreht wird) diese Werte an andere Funktionen weitergeben könnte.

So könnte dann ein Dimmer realisiert werden.

Hallo Leute,

komme im Moment einfach nicht mehr weiter. Ich habe den Rotary Poti und möchte die Positionsangaben welche an die Funktion cb_position kommen an andere Funktionen weitergeben. Doch das klappt leider nicht.

Hier die cb_position:

def cb_position(self, position):
    position = position +150
    return position

Ein Aufruf in einer anderen Funktion klappt nicht:

def test_function(self):
    pos = self.cb_position()

Was für eine Distribution benutzt du denn?

Startet es mit systemd, upstart oder sysvinit?

Für systemd habe ich in diesem Thread - http://www.tinkerunity.org/forum/index.php/topic,2233.msg15353.html#msg15353 - etwas geschrieben, aber so gut ist die Lösung noch nicht, eher quick & dirty.

Sorry für Doppelpost, aber 20.000 Zeichen sind zu wenig. 

2. Teil

Das Steuerungsskript:

#!/usr/bin/env python
# -*- coding: utf-8 -*-  

import sqlite3
import socket
import sys
import time
import math
import logging as log
log.basicConfig(level=log.INFO)

import Queue
import heapq
from threading import Thread, Event, Timer
from datetime import datetime

from tinkerforge.ip_connection import IPConnection
from tinkerforge.ip_connection import Error
from tinkerforge.brick_master import Master
from tinkerforge.bricklet_lcd_20x4 import LCD20x4
from tinkerforge.bricklet_ambient_light import AmbientLight
from tinkerforge.bricklet_humidity import Humidity
from tinkerforge.bricklet_barometer import Barometer
from tinkerforge.bricklet_temperature import Temperature

class weatherstation:
    HOST = "localhost"
    PORT = 4223

    line_length = 20
    button_pressed = None
    button_counter = [0, 0, 0, 0]

    ipcon = None
    lcd = None
    al = None
    hum = None
    baro = None
    temp_innen = None
    temp_aussen = None

    latest_illuminance = None
    latest_humidity = None
    latest_air_pressure = None
    latest_temperature_baro = None
    latest_temperature_innen = 0
    latest_temperature_aussen = 0

    illuminance_queue = Queue.Queue(86400)
    humidity_queue = Queue.Queue(86400)
    air_pressure_queue = Queue.Queue(86400)
    temperature_baro_queue = Queue.Queue(86400)
    temperature_innen_queue = Queue.Queue(86400)
    temperature_aussen_queue = Queue.Queue(86400)

    def __init__(self):
        self.ipcon = IPConnection()
        while True:
            try:
                self.ipcon.connect(weatherstation.HOST, weatherstation.PORT)
                break
            except Error as e:
                log.error('Connection Error: ' + str(e.description))
                time.sleep(1)
            except socket.error as e:
                log.error('Socket error: ' + str(e))
                time.sleep(1)

        self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE, self.cb_enumerate)
        self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED, self.cb_connected)

        while True:
            try:
                self.ipcon.enumerate()
                break
            except Error as e:
                log.error('Enumerate Error: ' + str(e.description))
                time.sleep(1)

    # Callbacks of the sensors
    # "if statements" for ongoing data on the lcd
    def cb_temperature_innen(self, temperature):
        self.latest_temperature_innen = temperature/100.0
        self.temperature_innen_queue.put(self.latest_temperature_innen)
        if self.temperature_innen_queue.full():
            self.temperature_innen_queue.get()
        if self.button_counter[1] % 4 == 1:
            text = 'Innentemp %7.2f \xDFC' % (self.latest_temperature_innen)
            self.lcd.write_line(0, 0, text)
        elif self.button_counter[1] % 4 == 2 or self.button_counter[1] % 4 == 3:
            text = 'Innen: %9.2f \xDFC' % (self.latest_temperature_innen)
            self.lcd.write_line(2, 0, text)            
        if self.button_pressed == 0:
            self.update_time()
        # Database
        connection = sqlite3.connect("/var/local/tinkerweather/tinkerweather.sqlite")
        cursor = connection.cursor()
        now = datetime.now()
        werte = (now, self.latest_temperature_innen)
        sql = "INSERT INTO temperature_innen VALUES (?, ?)"
        cursor.execute(sql, werte)
        connection.commit()
        #

    def cb_temperature_aussen(self, temperature):
        self.latest_temperature_aussen = temperature/100.0
        self.temperature_aussen_queue.put(self.latest_temperature_aussen)
        if self.temperature_aussen_queue.full():
            self.temperature_aussen_queue.get()
        if self.button_counter[1] % 4 == 2 or self.button_counter[1] % 4 == 3:
            text = 'Aussen: %8.2f \xDFC' % (self.latest_temperature_aussen)
            self.lcd.write_line(1, 0, text)
        if self.button_pressed == 0:
            self.update_time()
        # Database
        connection = sqlite3.connect("/var/local/tinkerweather/tinkerweather.sqlite")
        cursor = connection.cursor()
        now = datetime.now()
        werte = (now, self.latest_temperature_aussen)
        sql = "INSERT INTO temperature_aussen VALUES (?, ?)"
        cursor.execute(sql, werte)
        connection.commit()
        #

    def cb_illuminance(self, illuminance):
        self.latest_illuminance = illuminance/10.0
        self.illuminance_queue.put(self.latest_illuminance)
        if self.illuminance_queue.full():
            self.illuminance_queue.get()
        if self.button_counter[1] % 4 == 1:
            text = 'Helligkeit %6.2f lx' % (self.latest_illuminance)
            self.lcd.write_line(3, 0, text)
        if self.button_pressed == 0:
            self.update_time()
        # Database
        connection = sqlite3.connect("/var/local/tinkerweather/tinkerweather.sqlite")
        cursor = connection.cursor()
        now = datetime.now()
        werte = (now, self.latest_illuminance)
        sql = "INSERT INTO illuminance VALUES (?, ?)"
        cursor.execute(sql, werte)
        connection.commit()
        #

    def cb_humidity(self, humidity):
        self.latest_humidity = humidity/10.0
        self.humidity_queue.put(self.latest_humidity)
        if self.humidity_queue.full():
            self.humidity_queue.get()
        if self.button_counter[1] % 4 == 1:
            text = 'Luftfeuchte %5.2f %%' % (self.latest_humidity)
            self.lcd.write_line(1, 0, text)
        if self.button_pressed == 0:
            self.update_time()
        # Database
        connection = sqlite3.connect("/var/local/tinkerweather/tinkerweather.sqlite")
        cursor = connection.cursor()
        now = datetime.now()
        werte = (now, self.latest_humidity)
        sql = "INSERT INTO humidity VALUES (?, ?)"
        cursor.execute(sql, werte)
        connection.commit()
        #

    def cb_air_pressure(self, air_pressure):
        temperature = self.baro.get_chip_temperature()
        self.latest_temperature_baro = temperature/100.0
        self.latest_air_pressure = (air_pressure/1000.0)*((self.latest_temperature_aussen+273.15)/((self.latest_temperature_aussen+273.15)+(0.0065*520)))**-5.255
        self.air_pressure_queue.put(self.latest_air_pressure)
        if self.air_pressure_queue.full():
            self.air_pressure_queue.get()
        self.temperature_baro_queue.put(self.latest_temperature_baro)
        if self.temperature_baro_queue.full():
            self.temperature_baro_queue.get()
        if self.button_counter[1] % 4 == 2 or self.button_counter[1] % 4 == 3:
            text = 'Barometer: %4.2f \xDFC' % (self.latest_temperature_baro)
            self.lcd.write_line(3, 0, text)
        if self.button_counter[1] % 4 == 1:
            text = 'Luftdruck %7.2f hP' % (self.latest_air_pressure)
            self.lcd.write_line(2, 0, text)
        if self.button_pressed == 0:
            self.update_time()
        # Database
        connection = sqlite3.connect("/var/local/tinkerweather/tinkerweather.sqlite")
        cursor = connection.cursor()
        now = datetime.now()
        werte = (now, self.latest_air_pressure)
        sql = "INSERT INTO air_pressure VALUES (?, ?)"
        cursor.execute(sql, werte)
        connection.commit()
        #

    # Callback functions for buttons
    def cb_pressed(self, button):
        if button == self.button_pressed:
            #log.info('Button Counter: ' + str(self.button_counter))
            self.button_counter[button] = self.button_counter[button] + 1
        else:
            self.button_pressed = button
            self.button_counter = [0, 0, 0, 0]
        self.update_switch(button)

    #def cb_released(self, button):
        #log.info('Released: ' + str(button))

    # Turn the lcd on
    def lcd_on(self):
        self.lcd.clear_display()
        self.lcd.backlight_on()

    # Turn the lcd off
    def lcd_off(self):
        self.lcd.clear_display()
        self.lcd.backlight_off()

    # Functions for the lcd display
    # Button 0:
    def update_time(self):
        now = datetime.now()
        text = now.strftime('%d.%m.%Y')
        self.lcd.write_line(0, ((self.line_length-len(text))/2), text)
        text = now.strftime('%A') #%A, Woche %W
        self.lcd.write_line(1, ((self.line_length-len(text))/2), text)
        text = now.strftime('')
        self.lcd.write_line(2, ((self.line_length-len(text))/2), text)
        text = now.strftime('%H:%M:%S')
        self.lcd.write_line(3, ((self.line_length-len(text))/2), text)

    # Button 1:
    def update_standard(self):
        switch_lcd = self.button_counter[1] % 4
        if switch_lcd == 0 or switch_lcd == 1:
            text = 'Innentemp %7.2f \xDFC' % (self.latest_temperature_innen)
            self.lcd.write_line(0, 0, text)
            text = 'Luftfeuchte %5.2f %%' % (self.latest_humidity)
            self.lcd.write_line(1, 0, text)
            text = 'Luftdruck %7.2f hP' % (self.latest_air_pressure)
            self.lcd.write_line(2, 0, text)
            text = 'Helligkeit %6.2f lx' % (self.latest_illuminance)
            self.lcd.write_line(3, 0, text)
        elif switch_lcd == 2 or switch_lcd == 3:
            text = 'Temperatur'
            self.lcd.write_line(0, 0, text)
            text = 'Aussen: %8.2f \xDFC' % (self.latest_temperature_aussen)
            self.lcd.write_line(1, 0, text)
            text = 'Innen: %9.2f \xDFC' % (self.latest_temperature_innen)
            self.lcd.write_line(2, 0, text)
            text = 'Barometer: %4.2f \xDFC' % (self.latest_temperature_baro)
            self.lcd.write_line(3, 0, text)

    # Button 2:
    def update_min_max_avg(self):
        switch_lcd = self.button_counter[2] % 6
        if switch_lcd == 0:
            self.update_min_max_avg_write('Aussentemp ' + str(self.time_from_seconds(self.temperature_aussen_queue.qsize())), '\xDFC', self.get_min_max_avg(self.temperature_aussen_queue))
        elif switch_lcd == 1:
            self.update_min_max_avg_write('Innentemp ' + str(self.time_from_seconds(self.temperature_innen_queue.qsize())), '\xDFC', self.get_min_max_avg(self.temperature_innen_queue))
        elif switch_lcd == 2:
            self.update_min_max_avg_write('Barotemperatur ' + str(self.time_from_seconds(self.temperature_baro_queue.qsize())), '\xDFC', self.get_min_max_avg(self.temperature_baro_queue))
        elif switch_lcd == 3:
            self.update_min_max_avg_write('Luftfeuchte ' + str(self.time_from_seconds(self.humidity_queue.qsize())), '%', self.get_min_max_avg(self.humidity_queue))
        elif switch_lcd == 4:
            self.update_min_max_avg_write('Luftdruck ' + str(self.time_from_seconds(self.air_pressure_queue.qsize())), 'hPa', self.get_min_max_avg(self.air_pressure_queue))
        elif switch_lcd == 5:
            self.update_min_max_avg_write('Helligkeit ' + str(self.time_from_seconds(self.illuminance_queue.qsize())), 'lux', self.get_min_max_avg(self.illuminance_queue))

    def update_min_max_avg_write(self, title, unit, values):
        minimum = 'Minimum: ' + str(values[0]) + str(unit)
        average = 'Mittel.: ' + str(values[1]) + str(unit)
        maximum = 'Maximum: ' + str(values[2]) + str(unit)
        self.lcd.write_line(0, 0, title)
        self.lcd.write_line(1, 0, minimum)
        self.lcd.write_line(2, 0, average)
        self.lcd.write_line(3, 0, maximum)

    def time_from_seconds(self, s):
        string = None
        m = s/60
        h = m/60
        if h > 0:
            string = '(' + str(h) + 'h)'
        elif m >= 0:
            string = '(' + str(m) + 'm)'
        #log.info('Sekunden: ' + str(s))
        #log.info('Minuten: ' + string)
        return string

    def get_min_max_avg(self, q):
        minimum = None
        average = None
        maximum = None
        #log.info('Queue Size: ' + str(q.qsize()))
        #log.info('Queue full?:' + str(q.full()))
        heap = list(q.queue)
        heapq.heapify(heap)
        heap_length = len(heap)
        heap_sum = math.fsum(heap)
        average = round((heap_sum / heap_length), 2)
        minimum = round(min(heap), 2) #heapq.nsmallest(1, heap) #heap[0]
        maximum = round(max(heap), 2) #heapq.nlargest(1, heap)
        return minimum, average, maximum

    # Check which button is pressed, then update the lcd display
    def update_switch(self, button):
        if button == 0:
            #log.info('Update Time: Button ' + str(button))
            self.lcd_on()
            self.update_time()
        elif button == 1:
            #log.info('Update Standard: Button ' + str(button))
            self.lcd_on()
            self.update_standard()
        elif button == 2:
            #log.info('Update MinMaxAvg: Button ' + str(button))
            self.lcd_on()
            self.update_min_max_avg()
        elif button == 3:
            #log.info('Turn LCD Off: Button ' + str(button))
            self.lcd_off()

    # Initialize the bricklets
    def cb_enumerate(self, uid, connected_uid, position, hardware_version, firmware_version, device_identifier, enumeration_type):
        if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
           enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
            if device_identifier == LCD20x4.DEVICE_IDENTIFIER:
                try:
                    self.lcd = LCD20x4(uid, self.ipcon)
                    self.lcd.clear_display()
                    self.lcd.register_callback(self.lcd.CALLBACK_BUTTON_PRESSED, self.cb_pressed) # Button support
                    #self.lcd.register_callback(self.lcd.CALLBACK_BUTTON_RELEASED, self.cb_released)
                    log.info('LCD 20x4 initialized')
                except Error as e:
                    log.error('LCD 20x4 init failed: ' + str(e.description))
                    self.lcd = None
            elif device_identifier == AmbientLight.DEVICE_IDENTIFIER:
                try:
                    self.al = AmbientLight(uid, self.ipcon)
                    self.al.set_illuminance_callback_period(1000)
                    self.al.register_callback(self.al.CALLBACK_ILLUMINANCE, self.cb_illuminance)
                    log.info('Ambient Light initialized')
                except Error as e:
                    log.error('Ambient Light init failed: ' + str(e.description))
                    self.al = None
            elif device_identifier == Humidity.DEVICE_IDENTIFIER:
                try:
                    self.hum = Humidity(uid, self.ipcon)
                    self.hum.set_humidity_callback_period(1000)
                    self.hum.register_callback(self.hum.CALLBACK_HUMIDITY, self.cb_humidity)
                    log.info('Humidity initialized')
                except Error as e:
                    log.error('Humidity init failed: ' + str(e.description))
                    self.hum = None
            elif device_identifier == Barometer.DEVICE_IDENTIFIER:
                try:
                    self.baro = Barometer(uid, self.ipcon)
                    self.baro.set_air_pressure_callback_period(1000)
                    self.baro.register_callback(self.baro.CALLBACK_AIR_PRESSURE, self.cb_air_pressure)
                    log.info('Barometer initialized')
                except Error as e:
                    log.error('Barometer init failed: ' + str(e.description))
                    self.baro = None
            elif device_identifier == Temperature.DEVICE_IDENTIFIER and uid == 'neE': # Innen
                try:
                    self.temp_innen = Temperature(uid, self.ipcon) 
                    self.temp_innen.set_temperature_callback_period(1000)
                    self.temp_innen.register_callback(self.temp_innen.CALLBACK_TEMPERATURE, self.cb_temperature_innen)
                    log.info('Temperatur innen initialized')
                except Error as e:
                    log.error('Temperatur innen init failed: ' + str(e.description))
                    self.temp_innen = None
                #print(self.temp_innen.get_identity())
            elif device_identifier == Temperature.DEVICE_IDENTIFIER and uid == 'ns4': # Außen
                try:
                    self.temp_aussen = Temperature(uid, self.ipcon) 
                    self.temp_aussen.set_temperature_callback_period(1000)
                    self.temp_aussen.register_callback(self.temp_aussen.CALLBACK_TEMPERATURE, self.cb_temperature_aussen)
                    log.info('Temperatur aussen initialized')
                except Error as e:
                    log.error('Temperatur aussen init failed: ' + str(e.description))
                    self.temp_aussen = None
                #print(self.temp_aussen.get_identity())

    def cb_connected(self, connected_reason):
        if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
            log.info('Auto Reconnect')

            while True:
                try:
                    self.ipcon.enumerate()
                    break
                except Error as e:
                    log.error('Enumerate Error: ' + str(e.description))
                    time.sleep(1)

# Main Function
if __name__ == "__main__":
    log.info('Weatherstaion: Start\n')

    Weatherstation = weatherstation()

    if sys.version_info < (3, 0):
        input = raw_input # Compatibility for Python 2.x
    user_input = input('Press enter to exit.\n')

    log.info('Main program has exited!')

    if Weatherstation.lcd != None:
        Weatherstation.lcd_off()
    if Weatherstation.ipcon != None:
        Weatherstation.ipcon.disconnect()

    log.info('Weatherstation: End')

Damit das nun alles auch bei einem Systemstart automatisch gestart wird, habe ich dafür eine systemd-unit-file geschrieben:

[unit]
Description=Weatherstation
Requires=brickd.service
After=syslog.target

[service]
Type=simple
StandardInput=tty
TTYPath=/dev/tty24
Restart=always
RestartSec=30
ExecStart=/usr/bin/python /usr/local/bin/weatherstation.py

[install]
WantedBy=multi-user.target

Damit das Skipt unendlich läuft, habe ich die Eingabe auf tty24 gelegt, damit es nicht unterbrochen wird (gefällt mir eigentlich nicht so, wusste aber nicht, wie es einmal gestartet immer weiter läuft, vielleicht hat jemand eine Idee?).

So das war es erstmal. Wenn jemand noch Änderungen oder Verbesserungen hat bitte posten.

Hey Leute,

danke für eure Antworten und sorry für meine späte Antwort.

Habe zum Teil einige Punkte aus meinem ersten Post geschafft.

- Bei der fortlaufenden Anzeige des Datums habe ich ein bisschen geschummelt. Es hat leider nicht geklappt eine Funktion zu schreiben, die das Datum aktualisiert und auch auf die Tasten reagiert und so eine andere Seite anzeigt. Das "Schummeln" besteht jetzt darin, dass wenn die Callbacks aufgerufen werden, diese das Datum aktualisieren, wenn die Taste für das Datum gedrückt worden ist (weil ein Sensor ändert sich mindestens pro Sekunde).

- Habe es geschafft, dasss alle Sensoren sowohl in einer Queue, als auch in einer sqlite3 Datenbank gespeichert werden. 

- Leider klappt es bisher nicht, dass ein Timer nach einer gewissen Zeit das Display ausschaltet. Dafür ist Button 3 damit belegt.

Der Aufbau der Station ist wie folgt:

-RaspberryPi

-2 Master Bricks

-2 Temperatur Bricklets (einer für außen, einer für innen)

-1 Ambient Light Bricklet

-1 Humidity Bricklet

-1 Barometer Bricklet

-1 LCD Display Bricklet

Da ich den Luftdruck in hPa umrechne stellt sich die Frage, welche Temperatur zur Umrechnung benutzt werden sollte. Die von dem Außensensor oder von dem Innensensor?

Funktionsweise der Station:

-Button 0: Datumsanzeige

-Button 1: Anzeige 1: Wetterdaten von Temperatursensor(innen), Luftfeuchte, Luftdruck, Helligkeit

Anzeige 2: Temperatur von innen, aussen, Barometerchip

-Button 2: 6 Queues: Temperatur innen, aussen, Barometer, Luftfeuchtigkeit, Luftdruck, Helligkeit

-Button 3: Display aus

Jetzt noch die Skripte:

Ein wirklich ganz einfaches Skript zur Erstellung der sqlite Datenbank:

#!/usr/bin/env python
# -*- coding: utf-8 -*-  

import sqlite3

if __name__ == "__main__":
    connection = sqlite3.connect("/var/local/tinkerweather/tinkerweather.sqlite")
    cursor = connection.cursor()
    cursor.execute("""CREATE TABLE temperature_aussen (datum REAL, temperature_aussen REAL)""")
    cursor.execute("""CREATE TABLE temperature_innen (datum REAL, temperature_innen REAL)""")
    cursor.execute("""CREATE TABLE illuminance (datum REAL, illuminance REAL)""")
    cursor.execute("""CREATE TABLE humidity (datum REAL, humidity REAL)""")
    cursor.execute("""CREATE TABLE air_pressure (datum REAL, air_pressure REAL)""")
    connection.commit()
    connection.close()
    print("Database created.")

Hallo Leute,

bin nun endlich dazu gekommen, etwas mit der Wetterstation zu machen.

Mein Ziel ist es erstmal das Skript, welches verschieden Wetterdaten anzeigen kann ( http://www.tinkerforge.com/de/doc/Kits/WeatherStation/CSharpToButtonControl.html#starter-kit-weather-station-button-control-csharp ) von C# in Python zu übertragen.

Bisher klappt folgendes:

-Alle Buttons funktionieren 

-Button 0: Anzeige des Datums

-Button 1: Aktuelle Wetterdaten

-Button 2: Min-Max-Avg Daten

-Button 3: Display ausschalten

Was noch zu tun ist:

-Fortlaufende Aktualisierung des Datums

-Bisher nur Min-Max Werte für die Temperatur, auch die anderen Daten per Button anzeigen lassen

-Einen Timer, der nach einer bestimmten Zeit das Display ausschaltet

-Die Graphanzeige wäre auch cool

Anbei ist das bisherige Python-Skript.

Das Problem ist im Moment, wie ich eine fortlaufende Anzeige des Datums hinbekomme (while-Schleife), aber auch noch die anderen Buttons funktionieren.

Weil mit einer "while True"-Schleife komme ich nicht mehr aus der Anzeige raus.

Ebenso brauche ich eine Schleife/Thread, der die Queues befüllt, welche die Daten für die Min-Max-Avg und die Graphenanzeige bereitstellt. Mein Ansatz ist, dass im Hauptprogramm eine Schleife läuft, die jede Sekunde eine Update-Funktion aufruft, die die Daten in die Queues legt. Jedoch besteht auch dabei das Problem, dass ich das Programm nicht mehr mit Enter beenden kann, nur noch mit ctrl+c.

Dies ist mein erstes Python-Skript und hoffe, dass evtl. einer schon mal etwas mit Threads und co gemacht hat.

weatherstation_tf.py