Das deutsche Python-Forum

Code: Alles auswählen

 

    import time as t
    	from tkinter import*
    	import threading
    	import RPi.GPIO as gpio
    	diff = 0
    	diff2 = 0
    	notaus1 = 0
    	notaus2= 0
    	gpio.setmode(gpio.BCM)
    	gpio.setwarnings(False)
    	''' INPUT  definieren  '''
    	gpio.setup(16, gpio.IN, pull_up_down = gpio.PUD_DOWN) #start
    	#_________________________destroy_Funktion()__________________
    	def on_closing():
    	   
    	   window.destroy() 
    	#_____________________________PROBLEM IST HIER----(Taster_Funktion())________________
    	def GPIO_TASTER () :
    	  while gpio.input(16)== 1:
    	        statusbar1["text"] ="Button gedrückt"
    	         
    	threading.Thread(target=Funktion_knopf).start()   
    	  
    	   #_____________________________stop_BUTTON______________________________
    	def stop ():
    	   global notaus1
    	   global notaus2
    	   notaus1 = 1
    	   notaus2 = 1
    	   statusbar1["text"] ="STOP"
    	   
    	    
    	#" _________________________Start_Wischen_______________________________"
    	                #---------------Knopf-----------------
    	def Start_wischen ():
    	   global notaus1
    	   global notaus2
    	   notaus2 = 0.2
    	   statusbar1["text"] ="Start_Wischen"
    	   Wischen()
    	   
    	                # -------------Function()-------------
    	def Wischen () :
    	   if notaus1 != 0.1 :
    	        
    	        def Run2 ():
    	            
    	            global diff2
    	            start_t2 = t.time() 
    	            while notaus2==0.2 and  diff2 < 23 :
    	                end_t2 =t.time()
    	                diff_2 =int(end_t2 - start_t2)+1000
    	                statusbar2["text"] = ("time_Wischen is :", diff_2)
    	                
    	        threadd = threading.Thread(target=Run2).start()
    	        
    	#" _________________________ SENSOR-TEST_______________________________"
    	                #---------------Knopf-----------------
    	def Start_SensorTest () :
    	   global notaus1 
    	   global notaus2
    	   notaus1 =0.1
    	   statusbar1["text"] ="Start_Test"
    	   Test()
    	               # -------------Function()-------------
    	def Test (): 
    	   if notaus2 != 0.2 :
    	       
    	    def Run():
    	        
    	        global diff
    	        start_t = t.time()
    	        while notaus1 == 0.1   and diff < 15 :  
    	            end_t = t.time()
    	            diff = int(end_t - start_t)
    	            statusbar2["text"] = ("Test_time is :", diff)
    	            
    	    thread = threading.Thread(target=Run).start()
    	   
    	#" _________________________ GUI_______________________________"
    	window = Tk()
    	window.title("GUI")
    	#outputs
    	statusbar1 = Label(window, text="auf start druecken", width=25,height =5, borderwidth=15 ,relief = SUNKEN)
    	statusbar1.grid(row= 6, column = 2)
    	statusbar2 = Label(window, text="Time", width=25,height =5, borderwidth=15 ,relief = SUNKEN)
    	statusbar2.grid(row= 7, column = 2)
    	# variable to store input
    	b1=Button(window, text="SensorTest",command =Start_SensorTest)
    	b1.grid(row=2, column = 2, padx= (100,5), pady=5)
    	b2=Button(window, text="Startwischen ",command = Start_wischen)
    	b2.grid(row=3, column = 2, padx= (100,5), pady=5)
    	b3=Button(window, text="Abbrechen ",command =stop)
    	b3.grid(row=4, column = 2, padx= (100,5), pady=5)
    	window.protocol("WM_DELETE_WINDOW", on_closing)
    	window.mainloop()

Code: Alles auswählen

#!/usr/bin/env python3
import tkinter as tk
from functools import partial
from time import monotonic

from RPi import GPIO as gpio

BUTTON_PIN = 16


def update_status_bar(statusbar):
    #
    # FIXME This does not work in a GUI as a thread.  Use callbacks from `gpio`,
    # a `queue.Queue` and `after()` to communicate with the main thread.
    #
    while gpio.input(BUTTON_PIN):
        statusbar["text"] = "Button gedrückt"


def _run(
    time_label,
    notaus,
    diff,
    start_time,
    notaus_value,
    max_diff,
    diff_offset,
    label_prefix,
):
    if notaus.get() == notaus_value and diff.get() < max_diff:
        end_time = monotonic()
        diff.set(int(end_time - start_time) + diff_offset)
        time_label["text"] = f"{label_prefix}: {diff.get()}"
        time_label.after(
            100,
            _run,
            time_label,
            notaus,
            diff,
            start_time,
            notaus_value,
            max_diff,
            diff_offset,
            label_prefix,
        )


def start_sensor_test(notaus1, notaus2, diff, statusbar, time_label):
    notaus1.set(0.1)
    statusbar["text"] = "Start Test"
    if notaus2.get() != 0.2:
        _run(
            time_label, notaus1, diff, monotonic(), 0.1, 15, 0, "Test time is"
        )


def start_wischen(notaus1, notaus2, diff, statusbar, time_label):
    notaus2.set(0.2)
    statusbar["text"] = "Start Wischen"
    if notaus1.get() != 0.1:
        _run(
            time_label,
            notaus2,
            diff,
            monotonic(),
            0.2,
            23,
            1000,
            "Time wischen is",
        )


def on_stop(notaus1, notaus2, statusbar):
    notaus1.set(1)
    notaus2.set(1)
    statusbar["text"] = "STOP"


def main():
    try:
        gpio.setmode(gpio.BCM)
        gpio.setup(BUTTON_PIN, gpio.IN, pull_up_down=gpio.PUD_DOWN)

        window = tk.Tk()
        window.title("GUI")

        diff = tk.IntVar(value=0)
        diff2 = tk.IntVar(value=0)
        notaus1 = tk.DoubleVar(value=0)
        notaus2 = tk.DoubleVar(value=0)

        pack_options = {"padx": (100, 5), "pady": 5}
        sensor_test_button = tk.Button(window, text="Sensor Test")
        sensor_test_button.pack(**pack_options)
        start_wischen_button = tk.Button(window, text="Start wischen")
        start_wischen_button.pack(**pack_options)
        cancel_button = tk.Button(window, text="Abbrechen")
        cancel_button.pack(**pack_options)

        label_options = {
            "width": 25,
            "height": 5,
            "borderwidth": 15,
            "relief": tk.SUNKEN,
        }
        statusbar = tk.Label(window, text="auf start drücken", **label_options)
        statusbar.pack()
        time_label = tk.Label(window, text="Time", **label_options)
        time_label.pack()

        sensor_test_button["command"] = partial(
            start_sensor_test, notaus1, notaus2, diff, statusbar, time_label
        )
        start_wischen_button["command"] = partial(
            start_wischen, notaus1, notaus2, diff2, statusbar, time_label
        )
        cancel_button["command"] = partial(
            on_stop, notaus1, notaus2, statusbar
        )

        window.mainloop()
    finally:
        gpio.cleanup()


if __name__ == "__main__":
    main()