How to break out of a while True: loop with a button

To expand on Robert Peter Oakes answer, provided the buttons in the tkinter library are running within seperate threads which I imagine they are, the following code should work. If they don't work in separate threads, the code will be too busy in the loop to break out of

blinking = 1
def ledblink():
     blinking = 1
     while (blinking == 1):
          GPIO.output(13, True)
          time.sleep(.5)
          GPIO.output(13, False)
          time.sleep(.5)
      GPIO.output(13,false)

def ledoff():
     blinking = 0

button = Button(root, text = 'LED ON', command = ledblink)
button.pack()
offbutton = Button(root, text = 'LED OFF', command = ledoff)
offbutton.pack()

Consider trying to use a thread to blink the led rather than a while loop, the Python interpreter will most likely be intelligent enough to yield system resources during the time.sleep calls but putting it into a thread and yielding the thread during the sleep period would ensure this and possibly use less processor time.

To expand on Robert Peter Oakes answer, provided the buttons in the tkinter library are running within seperate threads which I imagine they are, the following code should work. If they don't work in separate threads, the code will be too busy in the loop to break out of

blinking = 1
def ledblink():
     blinking = 1
     while (blinking == 1):
          GPIO.output(13, True)
          time.sleep(.5)
          GPIO.output(13, False)
          time.sleep(.5)
      GPIO.output(13,false)

def ledoff():
     blinking = 0

button = Button(root, text = 'LED ON', command = ledblink)
button.pack()
offbutton = Button(root, text = 'LED OFF', command = ledoff)
offbutton.pack()

Consider trying to use a thread to blink the led rather than a while loop, the Python interpreter will most likely be intelligent enough to yield system resources during the time.sleep calls but putting it into a thread and yielding the thread during the sleep period would ensure this and possibly use less processor time.

lucie tozer wrote:

Consider trying to use a thread to blink the led rather than a while loop, the Python interpreter will most likely be intelligent enough to yield system resources during the time.sleep calls but putting it into a thread and yielding the thread during the sleep period would ensure this and possibly use less processor time.

This sort of performance advice is tricky. Sometimes the actual performance is quite different than you expect. As a matter of fact, we're blinking a led with a full-blown Linux system. A much simpler ARM CPU like an STM32F405 can blink a led. Wait-a-minute! A much simpler embedded CPU like an ATMEGA328 can also blink a led.... Wait-a-minute! A much simpler CPU like a pic10Fxxx can also blink a led.

So in fact, we're using a several (*) orders of magnitude larger system to blink a led than is actually required.

The reason we're using such an overpowered system is that we like the convenience of not having to worry about memory use or being wasteful of CPU cycles. So, first goal should be: Get things to work. Optimizing things is for later. Have fun seeing that led actually blink. Learn the basics. Later on, when things have become a big mess and even an overpowered Linux machine can't handle what you're throwing at it, does it make sense to start optimizing. But again: be warned that measurements as to what actually improves performance and what does not, can be surprising even to people who have been working in the field for decades.

So with MY decades of experience, I would think that it would be difficult to measure the difference between the separate thread or doing it the other way. But if there is a difference, I'd say the advantage goes the other way.... But I'll acknowledge that if it would matter for me, I'd have to do the measurements and if my initial guess is wrong, I wouldn't be surprised.

(*) After posting I decided to do a little math to verify my claim. If we look at "memory" as a measure for the "size" of a computing system, we have the pic at 100-200 bytes, the AVR one order of magnitude larger: 2k, the STM at two orders above that, 200k, and the raspberry pi with 1G over three orders of magnitude above that! A total of about 6 orders-of-manitude! A factor of a million! Wow!

Im not entirely certain where you think I would be suggesting using a different processor or microcontroller or why providing some math on "memory" of these other components are relevant.

I was helpful enough to provide a replacement code, what followed was merely a suggestion for a future improvement and something that I would probably do myself. tbh much of your reply is just blowing a simple suggestion out of proportion.

Sorry.

A famous saying goes "premature optimization is the root of all evil".

We're using a processor that is (in some respects) 1 million times more powerful than what is required for the task. Optimizing this is not necessary. Moreover, my GUESS is that your optimization is counter productive (but only a little).

So, IMHO, a more valid suggestion for "future improvement" would be: "Maybe putting the blink-a-led in a separate thread makes the code more readable. If you want to experiment with that you could try that".