stopping a python program at certain time and resuming temporarily with button

I’ll start by assuming that your code to display time and read temperature is working correctly. Also, since I don’t have a RaspberryPi with me, I’m focusing on how to organise your logic on the parts that I think you are having difficulty. My code to specifically turn the display on or off may be wrong, but I guess you figured that part out already. Since your question is about an elegant way to do this, the solution is obviously opinion-based. What I am proposing here is a simple but sound way to do it.

The first thing to notice is that you want two modes of operation. I’ll call them day_mode and night_mode. The behaviour you expect is quite different for each mode:

• day_mode: display is always on, when button 16 is pressed, the display should change from temperature to time. It should be active from 6:00 until 21:00
• night_mode: display is normally off. When button 16 is pressed, the display should turn on and display something (you didn’t specify, but I’ll assume it is the temperature). It should be active when day_mode is not active.

When thinking about modes, it usually helps to separate three things:

• What you need to do when you enter that mode of operation (for example, when you enter day_mode you should turn on the display and show the clock, when you enter night_mode you should turn off the display)
• What is the behaviour you want during the mode. In your case, it is what we discussed above.
• Any clean-up action needed when you exit the mode. Here none is needed, so we will skip this part.

So, let’s begin! From your original code, I’ll keep everything but the functions night, bright and the final loop. The first thing to do is create a function that tells in which mode we should be:

import datetime as dt
def which_mode():
    current_hour = dt.datetime.now().time().hour
    # In your code you seemed to need special behaviour between 6 and 7 and 18 and 21,
    # but since it was not in your question, I'm not including it here
    if 6 <= current_hour <= 21:
        return 'day_mode'
    else:
        return 'night_mode'

To represent the modes, I’ll use functions. If your problem were more complex, classes with specific enter, exit and during methods and a full blown state machine implementation would be needed. Since your problem is small, let’s use a small solution. Each mode is a function, and the fact that you are entering the mode is informed by a parameter is_entering. The function will also receive a signal indicating that the button was pressed (a rising edge, but change according to your implementation). Before that, we will create a function that displays time or temperature based on a parameter:

def display_what(what):
    if what == 0:  # Time
        display_time()
    else:   # Temperature
        display_temp()



display_info = 0   # 0 means time, 1 means temperature
def day_mode(is_entering=False, button_pressed=False):
    global display_info    # Not very elegant, but gets the job done
    if is_entering:
        # Here the display is turned on. I got the values from your `bright` function
        flp.set_brightness(12)
        flp.clear()
    # This is the `during` logic. Note that it will be run right after `entering` the first time
    if button_pressed:
        display_info = (display_info + 1) % 2   # Cycles between 0 and 1
        display_what(display_info)  # Update the display accordingly

For the night_mode function, we will need to keep a global variable to record when the button was last pressed. By convention, when it is smaller than 0, it means we are not counting the time (so we do not keep "clearing the display" all the time).

time_of_last_press = -1.0
def night_mode(is_entering=False, button_pressed=False):
    if is_entering:
        # Setup the dark display
        flp.clear()
        flp.set_brightness(0)
    if button_pressed:
        # Record when the button was pressed and display something
        time_of_last_press = time.time()
        flp.set_brightness(4)  # I understood from your code that at night the display is less bright
        display_what(1)  # Temperature? You can use a similar logic from day_mode to toogle the displays
    elif ((time.time() - time_of_last_press) > 10.0) and (time_of_last_press >= 0):
        flp.clear()
        flp.set_brightness(0)
        time_of_last_press = -1.0

Finally, the main loop becomes relatively simple: check what should be the next mode. If it is different from the current one, set is_entering as True. Then call the function for the current mode.

# Setup the GPIO to detect rising edges.
GPIO.add_event_detect(16, GPIO.RISING)

current_mode = None  # In the first run, this forces the `entering` code of the correct mode to run
while True:
    button_pressed = GPIO.event_detected(16)
    next_mode = which_mode()
    changed = next_mode != current_mode
    current_mode = next_mode
    if current_mode == 'day_mode':
        day_mode(changed, button_pressed)
    else:   # There are only two modes, but could be an elif if there were more modes
        night_mode(changed, button_pressed)
    time.sleep(0.2)

You may have noticed that there is some repetition: for example, in night_mode, the code to clear the display is the same code used when entering it, so you could actually call night_mode(True) to run that code again. Most importantly, there are two ifs that are similar: the one in which_mode and the one in the main loop. This can be fixed (and the code made more generic) if we change which_mode to return the function representing the mode, instead of a string. This may be a little more difficult to read if you are not used to functions returning functions, but it is a very flexible way of doing this sort of state machine:

# Must be defined after the functions `day_mode` and `night_mode` are defined
def which_mode():
    current_hour = dt.datetime.now().time().hour
    # In your code you seemed to need special behaviour between 6 and 7 and 18 and 21,
    # but since it was not in your question, I'm not including it here
    if 6 <= current_hour <= 21:
        return day_mode   # Note that this is not a string. It is a function!
    else:
        return night_mode


# Setup the GPIO to detect rising edges.
GPIO.add_event_detect(16, GPIO.RISING)

current_mode = None  # In the first run, this forces the `entering` code of the correct mode to run
while True:
    button_pressed = GPIO.event_detected(16)
    next_mode = which_mode()
    changed = next_mode != current_mode
    current_mode = next_mode
    current_mode(changed, button_pressed)  # Now current_mode is a reference to one of the two mode functions, so we just need to call it.
    time.sleep(0.2)