Discussion :

[apicultrice]

Bonjour,

J'ai un programme sous python qui tourne en boucle de 30mn dans lequel il y a une boucle de 2s
Le calcul du temps se fait avec "time.sleep(2)" mais en fonction des temps d'accès avec un fournisseur d'accès BDD (FREE) le calcul du temps global (30mn) et plus qu'aléatoire
D'où l'idée d'utiliser les "thread"
un thread avec le prg de base et le second qui permettrait de sortir de la boucle au bout des 30mn et la fin de la boucle de 2s

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
compt = 0   # RAZ compteur 
periode = 1800 
t_att = 2    
while (True):
  print ('code effectuée toute les 30mn')
  while (compt < periode):
    print ('code effectuée toute les 2s')
    time.sleep(t_att)
    compt = compt + t_att
  compt = 0   # RAZ compteur

heum, j'espère être assez clair
Merci d'avance

[wiztricks]

Salut,

Il n'y a pas de thread dans votre code... Vous voulez qu'on écrive çà pour vous?
Personnellement, une activité qui doit être exécutée toutes les 30ms doit se lancer via un utilitaire système équivalent à "cron" qu"on trouve sous Linux. Surtout si vous débutez car c'est pas si trivial d'écrire et de surveiller des programmes supposés tourner en 24/24.

- W

[apicultrice]

Oui je n'ai pas une grande expérience en python
je me débrouille dans ce qui est classique
J'ai regardé quelques exemples avec des thread mais j'avoue je ne sais pas mettre en oeuvre

[wiztricks]

J'ai regardé quelques exemples avec des thread mais j'avoue je ne sais pas mettre en oeuvre

Pour moi, il serait préférable d'utiliser "cron".
Après si vous voulez coder çà avec Python, vous pouvez le faire sans thread.
A la base votre soucis est de réaliser toutes les 30mns une tâche qui va durer plus ou moins mais un temps bien inférieur à 30 mns.
Imaginez T0, T1, T2,... ou Ti = T(i-1) + 30mns.
Donc on part à attendre que time.time() < Ti... à cet instant, on calcule T(i+1) puis on lance l'activité qui dure plus ou moins et on repart dans l'attente que time.time() < T(i+1)...
Avec Python, on pourrait écrire cela ainsi:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
import time
 
DELAY = 2 # nombre de secondes a attendre
wait_time = time.time() + DELAY
for x in range(10):
    if time.time() < wait_time:
        time.sleep(1.0)
        continue
    wait_time = time.time() + DELAY
    # do action
    print (time.time())
    time.sleep(0.01)

Bon Ok, pour tester je ne vais pas attendre 30mns et le "for x in range(10):" devrait être remplacé par un "while True:"... mais c'est juste pour vous donner l'idée.

- W

[tyrtamos]

Bonjour,

Voilà un petit code de principe pour qu'une fonction soit appelée périodiquement jusqu'à ce qu'on demande l'arrêt.

Le principe est assez simple: on a la fonction "Timer" du module threading qui peut appeler une fonction après un certain délai. Alors on va appeler ce Timer en boucle dans un thread.

A adapter au problème...

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
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import time
 
import threading
 
##############################################################################
def affiche(texte):
    print(texte)
 
##############################################################################
class Intervalle(threading.Thread):
 
    #=========================================================================
    def __init__(self, tempo, fonction, args=[], kwargs={}):
        super().__init__()
 
        self.tempo = tempo
        self.fonction = fonction
        self.args = args
        self.kwargs = kwargs
 
        self.encore = True  # pour permettre l'arret a la demande
        self.timer = None
 
    #=========================================================================
    def run(self):
        """partie qui s'exécute en tâche de fond
        """
        while self.encore:
            self.timer = threading.Timer(self.tempo, self.fonction, self.args, self.kwargs)
            self.timer.setDaemon(True)
            self.timer.start()
            self.timer.join()
 
    #=========================================================================
    def stop(self):
        """ empeche un nouveau lancement de la fonction et termine le thread
        """
        self.encore = False  
 
 
##############################################################################
if __name__ == '__main__':
 
    intervalle = Intervalle(1, affiche, ["toto"])
    intervalle.setDaemon(True)
    intervalle.start()
    #interval.join() # attente bloquante de l'arrêt du thread
    time.sleep(10) # attendre 10s pendant lesquelles la fonction est appelée
    intervalle.stop() # demande l'arrêt du thread

[wiztricks]

Salut,

Le principe est assez simple: on a la fonction "Timer" du module threading qui peut appeler une fonction après un certain délai. Alors on va appeler ce Timer en boucle dans un thread.

Le module sched mérite peut être d'être mieux connu:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import sched, time
 
 
scheduler = sched.scheduler(time.time, time.sleep)
 
DELAY = 2
def action(count):
    now = time.time()
    print (count, '%.0f' % now)
    if count > 0:
        scheduler.enterabs(now+DELAY, 1, action, argument=(count-1,))
 
scheduler.enter(0, 1, action, argument=(5,))
scheduler.run(blocking=True)

- W

[apicultrice]

Merci pour l'aide

En fait j'ai fait un time.time() avant d'entrer dans la boucle et un autre à la fin
calcul de la différence et si supérieur on sort
Cela résoud une partie de mon problème car en automatisme on a l'habitude de gérer "un chien de garde"
Donc qui calcul le temps maxi avant déclenchement si le temps de cycle devient trop long
Et c'est à ce moment qu'il est nécessaire d'avoir un prg qui tourne en //