基于PyQt5与DS18B20的树莓派3温度监控器标签更新问询

Hey there! I see you're working on building a temperature monitor with a Raspberry Pi 3, DS18B20 sensor, and PyQt5—plus you're planning to expand it with pH, EC sensors later. Since you're new to Python and PyQt5, let's walk through this step by step, focusing on getting your setup working smoothly and setting up a scalable foundation for future sensors:

Before integrating with PyQt5, make sure you can reliably read temperature data from the sensor:

• Enable 1-Wire on your Raspberry Pi:
  Run sudo raspi-config, navigate to Interface Options > 1-Wire, enable it, then reboot your Pi.
• Install a handy library for DS18B20:

  pip install w1thermsensor
  

• Test a basic temperature read script to confirm connectivity:

  from w1thermsensor import W1ThermSensor
  
  try:
      sensor = W1ThermSensor()
      temp = sensor.get_temperature()
      print(f"Current Temperature: {temp:.2f}°C")
  except Exception as e:
      print(f"Sensor Read Error: {str(e)}")
  

Since you used QT 4 Designer, note there are small API differences with PyQt5—here's how to adapt it:

First, scan through frameless.py and update any PyQt4 imports to their PyQt5 equivalents. For example, replace from PyQt4.QtGui import * with from PyQt5.QtWidgets import *.

• Open your UI file in QT Designer (or PyQt5's Designer if you have it) and add a widget to display temperature—like a QLabel named temp_display_label (this will let you update the temperature text dynamically).
• Save the updated UI and regenerate the frameless.py file if needed, or manually add the widget reference if you're editing the py file directly.

You’re right—threading is non-negotiable for multi-sensor setups (even single sensors will block your UI if you read them in the main thread). PyQt5 uses signals and slots to safely pass data from worker threads to the main UI thread:

Create a Worker Thread Class for DS18B20 #

This thread will handle continuous sensor reads without freezing your GUI:

from PyQt5.QtCore import QThread, pyqtSignal
from w1thermsensor import W1ThermSensor

class DS18B20Thread(QThread):
    # Define signals to send data/errors back to the main thread
    temperature_updated = pyqtSignal(float)
    sensor_error = pyqtSignal(str)

    def __init__(self):
        super().__init__()
        self.is_running = True
        self.sensor = W1ThermSensor()

    def run(self):
        # Main loop for reading sensor data
        while self.is_running:
            try:
                temp = self.sensor.get_temperature()
                self.temperature_updated.emit(temp)
                self.sleep(1)  # Adjust read interval (seconds) as needed
            except Exception as e:
                self.sensor_error.emit(f"Error: {str(e)}")
                self.sleep(2)  # Wait longer before retrying on error

    def stop(self):
        # Safely stop the thread when closing the app
        self.is_running = False
        self.wait()

Integrate the Thread with Your Main Window (runframeless.py) #

Now connect the thread’s signals to update your UI:

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow
from frameless import Ui_MainWindow  # Import your generated UI class

class TemperatureMonitor(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.init_sensor_thread()

    def init_sensor_thread(self):
        # Initialize and start the sensor thread
        self.temp_thread = DS18B20Thread()
        self.temp_thread.temperature_updated.connect(self.update_temp_display)
        self.temp_thread.sensor_error.connect(self.show_error)
        self.temp_thread.start()

    def update_temp_display(self, temperature):
        # Update the UI label with new temperature data
        self.temp_display_label.setText(f"Current Temperature: {temperature:.2f}°C")

    def show_error(self, error_msg):
        # Display sensor errors in the UI
        self.temp_display_label.setText(error_msg)

    def closeEvent(self, event):
        # Ensure the thread stops when the window closes
        self.temp_thread.stop()
        event.accept()

# Run the application
if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = TemperatureMonitor()
    window.show()
    sys.exit(app.exec_())

This setup is already ready to expand:

• For each new sensor (pH, EC), create a similar worker thread class with its own signals.
• Connect each thread’s signals to dedicated UI widgets (e.g., a ph_display_label for pH readings).
• All threads run independently, so your UI stays responsive even with multiple sensors active.

Quick Tip: If you want to manage multiple threads more cleanly, you can use a QThreadPool and QRunnable instead of individual QThread instances—but for a small number of sensors, individual threads are simpler to debug and maintain.

内容的提问来源于stack exchange，提问作者drk