Discussion :

[glokker]

Bonjour,

Depuis quelques semaines je bute sur un problème avec mon script.
Le but est de pouvoir gérer une pompe à eau avec un niveau d'eau associée.
Je souhaiterais savoir si il est possible de stopper et ensuite relancer une boucle While dans un thread ?
Je m'explique si le niveau est bas je veux pouvoir clicker sur le boutton start pour lancer ma pompe (a l'aide d'un relais +raspberry), le remplissage de ma cuve va activer mes détecteurs de niveau d'eau et arriver a full la pompe s'arrête.
Mais je veux surtout avoir la possibilité d'avoir un boutton d’arrêt d'urgence. Un bouton STOP qui me permet d'arrêter le script et surtout d’arrêter la pompe, et ensuite avoir la possibilité de relancer en pressant sur le boutton start.
Je suis passé par les thread avec python mais je n'arrive que le lancer une fois Start Stop ensuite j'ai le message d'erreur qui m'indique que je ne peux pas lancer plusieurs fois le même Thread.

Voici mon code :

Le bout html :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
<input type='button' id="bt1" onclick='window.location.assign("/start")' value="start" />
<input type='button' id="bt1" onclick='window.location.assign("/stop")' value="stop" />

Le code python :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
from flask import Flask, render_template, request
from threading import Thread, Event
from multiprocessing import Process, Value
from threading import Thread
import requests
import json
import urllib
import time
import threading
 
app = Flask(__name__)
 
class LoopThread(Thread):
    def __init__(self, stop_event, interrupt_event):
        self.stop_event = stop_event
        self.interrupt_event = interrupt_event
        Thread.__init__(self)
 
    def run(self):
        while not self.stop_event.is_set():
            self.loop_process()
            if self.interrupt_event.is_set():
                self.interrupted_process()
                self.interrupt_event.clear()
 
    def loop_process(self):
        print("Start my pump!")
        time.sleep(2)
 
    def interrupted_process(self):
        print("Pump stopped!")
 
STOP_EVENT = Event()
INTERRUPT_EVENT = Event()
thread = LoopThread(STOP_EVENT, INTERRUPT_EVENT)
threads = []
 
@app.route('/')
def index():
  link = requests.get('http://192.168.1.129/cgi-bin/toto.py')
  return render_template('main.html', index=json.loads(link.text))
 
#def shutdown_server():
#    func = request.environ.get('werkzeug.server.shutdown')
#    if func is None:
#        raise RuntimeError('Not running with the Werkzeug Server')
#    func()
 
@app.route('/start', methods=['GET'])
def start():
    local_threads = []
    thread = LoopThread(STOP_EVENT, INTERRUPT_EVENT)
    local_threads.append(thread)
    print thread.is_alive()
    for thread in local_threads:
        if not thread.is_alive():
                thread = thread.clone()
                thread.start()
                print 'Thread starting...', thread.is_alive()
    print 'Pump starting...'
    return render_template('main.html')
 
@app.route('/stop', methods=['GET'])
def stop():
    STOP_EVENT.set()
    INTERRUPT_EVENT.set()
    print 'Pump stopping...'
    return render_template('main.html')
 
@app.route("/interrupt")
def interrupt():
    INTERRUPT_EVENT.set()
    return "OK", 200
 
 
if __name__ == '__main__':
 
        app.run(host='0.0.0.0', port=8000, debug='true')

Est-ce que je vais dans le bon sens ou est-ce que je m'acharne pour rien et que cela n'est pas possible ?

Y a t-il un autre moyen de pouvoir arriver au même résultat ?

Je sèche, je n'ai plus d'idée
Merci par avance pour votre aide.

[wiztricks]

Est-ce que je vais dans le bon sens ou est-ce que je m'acharne pour rien et que cela n'est pas possible ?

Je n'aurais pas fait comme çà mais l'idée devrait fonctionner (avec Flask s’entend).

Merci par avance pour votre aide.

Vous avez deux difficultés à essayer de séparer: la gestion du thread (qui contrôle la pompe) et le changement de son état via des requêtes HTTP.
Côté gestion du thread, vous avez déjà un soucis car je ne comprend pas pourquoi un thread est démarré avant avoir reçu "start" ni pourquoi "start" crée un thread à chaque appel. Maintenant "pour séparer les difficultés", plutôt que de contrôler déjà vos threads via HTTP, une boucle while qui récupère une entrée et qui lance "start", "stop", ... à la demande vous permettrait d'y voir un peu plus clair.
Une fois que cette partie "fonctionne" de façon satisfaisante, changer la saisie clavier par des requêtes HTTP sera bien plus facile.

- W

[glokker]

Je vous remercie pour votre retour.

Je dois dire que j'étais pessimiste à trouver une solution. Votre commentaire m'a remotivé et je pense avoir trouvé une solution.

J’exécute dorénavant le thread une fois le bouton start cliqué en déclarant des variables globales et je ferme le thread avec thread.join() une fois le bouton stop cliqué.

Le code n'est pas encore parfait mais cette fois, ça tourne comme je le souhaite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
from flask import Flask, render_template, request
from threading import Thread, Event
from multiprocessing import Process, Value
from threading import Thread
import requests
import json
import urllib
import time
import threading
 
app = Flask(__name__)
 
class LoopThread(Thread):
    def __init__(self, stop_event, interrupt_event):
        self.stop_event = stop_event
        self.interrupt_event = interrupt_event
        Thread.__init__(self)
 
    def run(self):
        while not self.stop_event.is_set():
            self.loop_process()
            if self.interrupt_event.is_set():
                self.interrupted_process()
                self.interrupt_event.clear()
 
    def loop_process(self):
        print("Start my pump!")
        time.sleep(2)
 
    def interrupted_process(self):
        print("Pump stopped!")
 
 
@app.route('/')
def index():
  link = requests.get('http://192.168.1.129/cgi-bin/toto.py')
  return render_template('main.html', index=json.loads(link.text))
 
def shutdown_server():
    func = request.environ.get('werkzeug.server.shutdown')
    if func is None:
        raise RuntimeError('Not running with the Werkzeug Server')
    func()
 
@app.route("/kill")
def shutdown():
    STOP_EVENT.set()
    thread.join()
    shutdown_server()
    return "OK", 200
 
@app.route('/start', methods=['GET'])
def start():
    global thread
    global STOP_EVENT
    global INTERRUPT_EVENT
    STOP_EVENT = Event()
    INTERRUPT_EVENT = Event()
    thread = LoopThread(STOP_EVENT, INTERRUPT_EVENT)
    threads = []
    if not thread.is_alive():
      print 'Thread starting...', thread.is_alive()
      thread.start()
      print 'Pump starting...', thread.is_alive()
    return render_template('main.html')
 
@app.route('/stop', methods=['GET'])
def stop():
    print thread.is_alive()
    interrupt()
    print 'Pump stopping...'
    thread.join()
    print thread.is_alive()
    return render_template('main.html')
 
@app.route("/interrupt")
def interrupt():
    STOP_EVENT.set()
    INTERRUPT_EVENT.set()
    return "OK", 200
 
 
if __name__ == '__main__':
 
        app.run(host='0.0.0.0', port=8000, debug='true')