7

I have just started with Python, although I have been programming in other languages over the past 30 years. I wanted to keep my first application simple, so I started out with a little home automation project hosted on a Raspberry Pi.

I got my code to work fine (controlling a valve, reading a flow sensor and showing some data on a display), but when I wanted to add some web interactivity it came to a sudden halt. Most articles I have found on the subject suggest to use the Flask framework to compose dynamic web pages. I have tried, and understood, the basics of Flask, but I just can't get around the issue that Flask is blocking once I call the "app.run" function. The rest of my python code waits for Flask to return, which never happens. I.e. no more water flow measurement, valve motor steering or display updating.

So, my basic question would be: What tool should I use in order to serve a simple dynamic web page (with very low load, like 1 request / week), in parallel to my applications main tasks (GPIO/Pulse counting)? All this in the resource constrained environment of a Raspberry Pi (3). If you still suggest Flask (because it seems very close to target), how should I arrange my code to keep handling the real-world events, such as mentioned above?

(This last part might be tough answering without seeing the actual code, but maybe it's possible answering it in a "generic" way? Or pointing to existing examples that I might have missed while searching.)

Eriond
  • 73
  • 1
  • 5

3 Answers3

10

You're on the right track with multithreading. If your monitoring code runs in a loop, you could define a function like

def monitoring_loop():
    while True:
        # do the monitoring

Then, before you call app.run(), start a thread that runs that function:

import threading
from wherever import monitoring_loop

monitoring_thread = threading.Thread(target = monitoring_loop)
monitoring_thread.start()

# app.run() and whatever else you want to do

Don't join the thread - you want it to keep running in parallel to your Flask app. If you joined it, it would block the main execution thread until it finished, which would be never, since it's running a while True loop.

To communicate between the monitoring thread and the rest of the program, you could use a queue to pass messages in a thread-safe way between them.

Josh Karpel
  • 2,110
  • 2
  • 10
  • 21
  • Wow! A to-the-point answer within 10 minutes. You just have to love StackOverflow! Could I be so rude as to ask for a pointer to some working code that uses this technique? (Just to understand it in a larger context). – Eriond Oct 29 '17 at 22:14
  • I'm afraid that I don't have any concise examples handy personally, but the [PyMOTW 3 post](https://pymotw.com/3/threading/) post on it looks like a good introduction with short examples. – Josh Karpel Oct 29 '17 at 22:17
0

The way I would probably handle this is to split your program into two distinct separately running programs.

One program handles the GPIO monitoring and communication, and the other program is your small Flask server. Since they run as separate processes, they won't block each other.

You can have the two processes communicate through a small database. The GIPO interface can periodically record flow measurements or other relevant data to a table in the database. It can also monitor another table in the database that might serve as a queue for requests.

Your Flask instance can query that same database to get the current statistics to return to the user, and can submit entries to the requests queue based on user input. (If the GIPO process updates that requests queue with the current status, the Flask process can report that back out.)

And as far as what kind of database to use on a little Raspberry Pi, consider sqlite3 which is a very small, lightweight file-based database well supported as a standard library in Python. (It doesn't require running a full "database server" process.)

Good luck with your project, it sounds like fun!

sql_knievel
  • 1,199
  • 1
  • 13
  • 26
0

Hi i was trying the connection with dronekit_sitl and i got the same issue , after 30 seconds the connection was closed.To get rid of that , there are 2 solutions:

  1. You use the decorator before_request:in this one you define a method that will handle the connection before each request
  2. You use the decorator before_first_request : in this case the connection will be made once the first request will be called and the you can handle the object in the other route using a global variable

For more information https://pythonise.com/series/learning-flask/python-before-after-request

J. Murray
  • 1,460
  • 11
  • 19
joekrom
  • 280
  • 2
  • 7