LedBlink | Arduino full stack tutorial

You are creating lots of threads because your blink() creates a new thread every time it is called and the old one isn't stopped.

I suppose there are a couple of options with the thread:

1. Create the thread just once - for example in __init__() - and it runs continuously on the blinking time intervals (i.e. sleeping most of the time) reading an instance variable and setting the LED correspondingly. To change the led state, the blink(), on() and off() control the led by setting this instance variable to on/off/blinking.

2. In the blink routine, if the thread is already running either don't create a new thread, or stop the old thread (and wait for it to finish) and then start a new one.

Things you will have to handle are that you want the behaviour to be that:

• If the led is off then the led turns on as soon as on() or blink() is called
• If the led is blinking and blink() is called again the blinking on/off sequence is not disturbed
• If blinking and off() is called I would want the on-cycle if it has started to run to completion, i.e. the led should not be turned off immediately because that might be a very short flash which would look odd.

The catch with creating a new thread is waiting for the old one to finish, and it just feels simplest to create the thread just once in __init__() and have it running continuously. When the led is on or off, the time period is shortened (to value FAST_CYCLE) so that when the led is turned off or on it reacts quickly because the sleep() is for a short time.

Some other points about your code:

• I don't think you need to make your class inherit from Thread - you are creating a new thread in the pin=... line.
• If you add comments as you write the code, usually makes it easier to understand what is going on when reading the code.
• If you keep a reference to the thread (i.e. self.pin = threading.Thread not pin = threading.Thread) then in the reset() you can use join() to make sure it has exited before you continue
• As the blink time periods can change and the thread has to use the latest values, use self to read them every time rather than pass them as arguments to the __blink_pin() routine, and if doing that you might as well use self to get the pin_stop semaphore too.

Something like this (untested):

The serial monitor sends symbols encoded in the ASCII format.

e.g. when you enter 0, Serial.read() returns 48, which is the ASCII code for digit 0. Since the value 48 is not listed in the following cases, the default branch is taken: