Das deutsche Python-Forum

Code: Alles auswählen

import time
import time
import pigpio

import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306

import RPi.GPIO as gpio

from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import subprocess

##Gpio Einstellungen
Taster10_up = 23
Taster10_down = 24
Taster01_up = 25
Taster01_down = 26
Relay1 = 5

gpio.setwarnings(False)
  
gpio.setmode(gpio.BCM)
gpio.setup(Taster10_up, gpio.IN) #Taster10_up
gpio.setup(Taster10_down, gpio.IN) #Taster10_down
gpio.setup(Taster01_up, gpio.IN) #Taster01_up
gpio.setup(Taster01_down, gpio.IN) #Taster01_down
gpio.setup(Relay1, gpio.OUT)  #Relay1 für Heizspule

##Sensor einlesen    
pi = pigpio.pi()
sensor = pi.spi_open(0, 1000000, 0)
if not pi.connected:
    exit(0)
       
# Raspberry Pi pin configuration:
RST = None     
DC = 23
SPI_PORT = 0
SPI_DEVICE = 0

# 128x64 display with hardware I2C:
disp = Adafruit_SSD1306.SSD1306_128_64(rst=RST)
disp.begin()
# Clear display.
disp.clear()
disp.display()
# Create blank image for drawing.
width = disp.width
height = disp.height
image = Image.new('1', (width, height))
# Get drawing object to draw on image.
draw = ImageDraw.Draw(image)
# Draw a black filled box to clear the image.
draw.rectangle((0,0,width,height), outline=0, fill=0)
# First define some constants to allow easy resizing of shapes.
padding = -2
top = padding
bottom = height-padding
# Move left to right keeping track of the current x position for drawing shapes.
x = 0
# Load default font.
font = ImageFont.load_default()
# Alternatively load a TTF font.  Make sure the .ttf font file is in the same directory as the python script!
# Some other nice fonts to try: http://www.dafont.com/bitmap.php
# font = ImageFont.truetype('Minecraftia.ttf', 8)
def LCD_Temperatur():
        # Draw a black filled box to clear the image.
    draw.rectangle((0,0,width,height), outline=0, fill=0)
        # Shell scripts for system monitoring from here : https://unix.stackexchange.com/questions/119126/command-to-display-memory-usage-disk-usage-and-cpu-load
    cmd = "hostname -I | cut -d\' \' -f1"
    IP = subprocess.check_output(cmd, shell = True )
    cmd = "top -bn1 | grep load | awk '{printf \"CPU Load: %.2f\", $(NF-2)}'"
        

    draw.text((x, top),       "IP: " + str(IP),  font=font, fill=255)
    draw.text((x, top+16),     "Isttemp = " + str(isttemp) + " °C", font=font, fill=255)
    draw.text((x, top+32),     "Solltemp = " + str(solltemp) + " °C", font=font, fill=255)
    draw.text((x, top+48),     "Hysterese = +-" + str(hysterese) + " °C", font=font, fill=255)
        # Display image.
    disp.image(image)
    disp.display()
    #time.sleep(.1)


def getSensorTemp():
    c, d = pi.spi_read(sensor, 2)
    if c == 2:
        word = (d[0]<<8) | d[1]    #shift bits
        if (word & 0x8006) == 0: # Bits 15, 2, und 1 müssen 0 sein (lt. Datenblatt).
            t = (word >> 3)/4.0
            Istwert = t
            print("{:.2f}".format(t))
        else:
            print("bad reading {:b}".format(word))
            Istwert = 987
    return Istwert   

    pi.spi_close(sensor)

    pi.stop()


solltemp = float(input("Sollwert: "))
hysterese = float(input("Hysterese: "))
                 
while True:     ##Hier sollte eigentlich eine Abfrage eines Starttasters stattfinden
    Tempmax = (solltemp+hysterese)
    Tempmin = (solltemp-hysterese)
            
    isttemp = getSensorTemp()
    LCD_Temperatur()
    time.sleep(0.5)

    if isttemp < Tempmin:
        #print("relay an")
        gpio.output(Relay1, gpio.HIGH)
    elif isttemp > Tempmax:
        #print ("relay aus")
        gpio.output(Relay1, gpio.LOW)

Code: Alles auswählen

import tkinter as tk
import requests

HEIGHT = 500
WIDTH = 900
Solltemperatur = 0

def get_Solltemperatur(entry):
    print(entry)
    
root = tk.Tk()

canvas = tk.Canvas(root, height=HEIGHT, width=WIDTH)
canvas.pack()

##Ausgabe Temperatur1 (Isttemperatur)
#Rahmen erstellen
frameA = tk.Frame(root, bg='#A0A0A0', height=100, width=50)
frameA.place(relx=0.5, rely=0.1, relwidth=0.75, relheight=0.1, anchor='n')



##Eingabe Solltemperatur
#Rahmen erstellen
frameB = tk.Frame(root, bg='#A0A0A0', height=100, width=50)
frameB.place(relx=0.5, rely=0.25, relwidth=0.75, relheight=0.1, anchor='n')

#Label erstellen
Solltemperatur_label = tk.Label(frameB, bg='#A0A0A0', text='Solltemperatur')
Solltemperatur_label.place(rely=0.1, relwidth=0.25, relheight=0.8)

#Eingabefeld erstellen
Solltemperatur_entry = tk.Entry(frameB, font=40)
Solltemperatur_entry.place(relx=0.3,rely=0.1, relwidth=0.25, relheight=0.8)

#Button erstellen
OK_btn = tk.Button(frameB, bg='#ff8000', text='OK', bd=2, command=lambda: get_Solltemperatur(Solltemperatur_entry.get()))
OK_btn.place(relx=0.7,rely=0.1, relheight=0.8, relwidth=0.25)


root.mainloop()

Code: Alles auswählen

#!/usr/bin/env python3
import subprocess
import sys
import time
from collections import namedtuple

import Adafruit_SSD1306
import pigpio
from loguru import logger
from PIL import Image, ImageDraw, ImageFont
from RPi import GPIO as gpio

TEN_UP_BUTTON_PIN = 23
TEN_DOWN_BUTTON_PIN = 24
ONE_UP_BUTTON_PIN = 25
ONE_DOWN_BUTTON_PIN = 26
HEATING_COIL_PIN = 5

DISPLAY_RST = None

Display = namedtuple("Display", "display image draw font x_offset y_offset")


def create_display(rst, x_offset=0, y_offset=0):
    display = Adafruit_SSD1306.SSD1306_128_64(rst)
    display.begin()
    display.clear()
    display.display()
    image = Image.new("1", (display.width, display.height))
    return Display(
        display,
        image,
        ImageDraw.Draw(image),
        ImageFont.load_default(),
        x_offset,
        y_offset,
    )


def update_display(display, lines):
    display.draw.rectangle(
        (0, 0, display.image.width, display.image.height), outline=0, fill=0
    )
    for i, line in enumerate(lines):
        display.draw.text(
            (display.x_offset, display.y_offset + i * 16),
            line,
            font=display.font,
            fill=255,
        )
    display.display.image(display.image)
    display.display.display()


def get_temperature(pi, sensor_handle):
    temperature = float("nan")
    byte_count, data = pi.spi_read(sensor_handle, 2)
    if byte_count == 2:
        word = (data[0] << 8) | data[1]
        #
        # Bits 15, 2, und 1 müssen 0 sein, laut Datenblatt.
        #
        if (word & 0b1000_0000_0000_0110) == 0:
            temperature = (word >> 3) / 4
            logger.debug("{:.2f}°C", temperature)
        else:
            logger.error("bad reading {:b}", word)
    else:
        logger.error("wrong byte count: {}", byte_count)

    return temperature


#
# TODO Die Funktion ist zu lang.  Sinnvoll in Funktionen aufteilen.
#
@logger.catch
def main():
    try:
        gpio.setmode(gpio.BCM)
        gpio.setup(
            [
                TEN_UP_BUTTON_PIN,
                TEN_DOWN_BUTTON_PIN,
                ONE_UP_BUTTON_PIN,
                ONE_DOWN_BUTTON_PIN,
            ],
            gpio.IN,
        )
        gpio.setup(HEATING_COIL_PIN, gpio.OUT)

        pi = pigpio.pi()
        try:
            if not pi.connected:
                sys.exit(1)
            temperature_sensor_handle = pi.spi_open(0, 1_000_000)
            try:
                display = create_display(DISPLAY_RST, 0, -2)
                target_temperature = float(input("Sollwert: "))
                hysteresis = float(input("Hysterese: "))
                min_temperature = target_temperature - hysteresis
                max_temperature = target_temperature + hysteresis
                #
                # TODO Hier sollte eigentlich eine Abfrage eines Starttasters
                # stattfinden.
                #
                while True:
                    #
                    # TODO `psutil` statt eines externen Programms verwenden.
                    # Und dann möchte man auch die Netzwerkschnittstelle angeben
                    # von der man die IP haben möchte und nicht einfach
                    # irgendeine der Möglichkeiten zufällig auswählen.
                    #
                    ip_addresses = subprocess.check_output(
                        "hostname --all-ip-addresses", universal_newlines=True
                    ).split()
                    temperature = get_temperature(
                        pi, temperature_sensor_handle
                    )
                    update_display(
                        display,
                        [
                            "IP: {}".format(ip_addresses[0]),
                            "Isttemp. = {:.2f} °C".format(temperature),
                            "Solltemp. = {:.2f} °C".format(target_temperature),
                            "Hysterese = +-{:2f} °C".format(hysteresis),
                        ],
                    )
                    if temperature < min_temperature:
                        logger.debug("relay an")
                        gpio.output(HEATING_COIL_PIN, gpio.HIGH)
                    elif temperature > max_temperature:
                        logger.debug("relay aus")
                        gpio.output(HEATING_COIL_PIN, gpio.LOW)

                    time.sleep(0.5)
            finally:
                pi.spi_close(temperature_sensor_handle)
        finally:
            pi.stop()
    finally:
        gpio.cleanup()


if __name__ == "__main__":
    main()