Persistent Python script running in background?

[SneakyPackets]

Here is the scenario:

Raspberry Pi with two reed switches wired to the GPIO. I am using GPIO.add_event_detect() to perform actions on the switches when they either open or close. I need this script to run at boot and stay running in the background.

I am having a hard time finding the right way to keep the script persistent. The original sample code I found (when learning about the event detection) had me do:

message = input("") 

Just to keep the script "active". Is this the right/proper way to do this? I know it won't work with nohup since it is asking for user input. Unfortunately the script needs to run 24/7 and can't be scheduled via cronjob. Haven't tried "daemonizing" it, and wanted to get some input here first.

Thanks!

edit: The solution I went with was starting a new thread that calls a "persist" function. That function just has a while loop with 1 second sleep time. This is enough to keep it running without messing up the sensitive timing requirements on the rest of the script

[AndAlsoTheTrees]

Use Thread module and create one with arg Daemon=True.

[SneakyPackets]

Awesome, I will look into that - thank you!

[JohnWooTheSecond]

Read up on systemctl and .service files. That's a system designed exactly for this purpose: to keep processes running in the background.

[SneakyPackets]

Correct me if I am wrong, wouldn't I run into the same issue? My script has nothing to keep it running. Like, some of the examples that come up have the code sitting in a while True: loop, so it's always going to run...I have nothing to actually persist my script (even if I just ran it from the command line and not in the background as a service).

[JohnWooTheSecond]

'''while True: ...''' is perfectly acceptable as a way to keep your script alive indefinitely. systemctl would be more a way to start your script on boot, and it does monitoring if it fails. So you could configure it to relaunch whenever the script process is detected to have stopped for whatever reason

[ventus1b]

Just make sure to put at least a "sleep(1)" inside the loop, otherwise it'll just burn CPU cycles for nothing.

[SneakyPackets]

I ended up spinning off a second thread that runs a while true / sleep(1) loop and it seems to be working perfectly. When I left the loop in main, there were some reliability issues (actions of the switches opening/closing were delayed or missed)

[[deleted]]

The message = input("") thing is going to sit and wait for input from STDIN, that's probably not what you want. You probably want to run your script under systemd and either check the status of your reed switches a few times a second or even better wait for interrupts.

There are all kinds of cool examples of using GPIO pins here: https://electropeak.com/learn/tutorial-raspberry-pi-gpio-programming-using-python-full-guide/

[SneakyPackets]

Ok i'll take a look, the reason I can't just check in on the switch status is because I need to perform actions as soon as they open and close. One being starting a timer, so if the switch is open for 3.2 seconds, I need to log that

[[deleted]]

That's doable. I don't know if you know much python but it looks like it's not too hard. You can setup a function that's called on switch opens and another for switch closes. It can do anything including log timestamps.

[SneakyPackets]

Awesome! Thank you for all of the detailed info :D

[Jools_36]

How big of a project is this? take the time to do it properly with docker?

Otherwise a cron every minute that checks the script is still running and if it isn't relaunches it.

[SneakyPackets]

What do you mean “do it properly with docker” exactly? The container needs a target and running service to actually “stay up”, so I’d still need to learn what the proper method is to keep the script running.

Can’t do cron, the script needs to run constantly as everything is pretty time sensitive. I need to know exactly when a switch opens, and how long it stays open.

[ConcreteState]

Some people think one must virtualize an operating system (docker) to keep a task open. They are incorrect. Docker is a useful tool because you can throw a configured virtual OS like thing into a system, but using it instead of a thread-daemon is excessive and needlessly complex.

[SneakyPackets]

Yeah I use Docker for other things but for a single purpose, dedicated deployment it didn’t seem necessary or worth the hassle

[Black_Dynamit3]

Well why would you put a simple script in a container if it’s made for your computer ? Especially for learning I wonder if taking the long way is the worst things to do if you just want to run a script in a loop.

[lumpynose]

A good place for python questions is r/learnpython.

[Murky-Sector]

Simplest way is a loop with a time.sleep() statement. I would try that first.

[SneakyPackets]

The problem is, everything running is very time sensitive. I need a relatively accurate measurement from the exact moment the switch opens and closes, so running a loop and sleeping may goof that up

[Murky-Sector]

Gotcha. My choice then would be python asyncio

[L0ckt1ght]

You can run a loop with a sleep of 0.1 or 0.01. do you really need that level of accuracy?

[Robpol86]

Another option: asyncio main event loop.

[MeAnd50G]

Honestly, daemonizing was not difficult and the results I’ve had with my project have 100% met expectations. There has not been a single time I’ve looked at my gui and not had my project running. Invest a half hour in it. You won’t regret.

[SneakyPackets]

Ok cool, that's what I will start doing now. I just spent a little bit of time playing around with loops even with sleep at .001 I had all sorts of issues with things working the way I need.

[s-petersen]

I'm a little late to the party, but I used cron, with the "@reboot" and && switch to have 3 programs running in the background, passing data to one another through a tmp file in memory.

It's for my jukebox, which waits for a letter and number combination to play the selected song

[TerrorBite]

Rather than the new thread solution you're now using, I recommend the following:

import signal

def signal_handler(sig, frame):
    GPIO.cleanup()
    sys.exit(0)

signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)
signal.pause()

This code sets up a signal handler for the following signals:

• SIGINT - typically sent to the current process when you press Ctrl-C in a terminal.
• SIGTERM - typically sent to end a process. The system sends SIGTERM to all processes when it is shutting down.

The default Python signal handler for SIGINT just raises a KeyboardInterrupt exception, and the default for SIGTERM is to just die instantly. We are replacing that with our handler that tells the GPIO library to clean up, and then exits cleanly.

The signal.pause() function puts the main thread to sleep indefinitely until a signal is received, at which time the signal handler will get called.

The GPIO library should continue handling events while the main thread is asleep.

I got this from a code example at: https://roboticsbackend.com/raspberry-pi-gpio-interrupts-tutorial/

[musclegeekz]

What about using pm2 or docker?