Détections sur entrées de GPIO et traitement associé

Version imprimable

Bonjour à tous

La structure suivante est utilisée pour afficher les données de course d'un circuit 24.
Or si les voitures passent en même temps la ligne, la deuxième détection est perdue.
Pourriez vous me dire si par le threading ou par autre chose je peux améliorer mon programme

Merci d'avance

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Tant que...
        if attentePassage() == 1:
            ...
            texte1 = pilote1
            texte4 = calculTempsTour()
            Mise a jour de champs dans une fenêtre...
            ...
 
        else:
            texte1 = pilote2
            texte4 = calculTempsTour()
            Mise a jour de champs dans une fenêtre...
            ...
        ...

Code:

1
2
3
4
5
6
7
def attentePassage():
    while True:
        if GPIO.input(button1)==0: 
            return(1) #renvoi numPiste = 1
 
        if GPIO.input(button2)==0: 
            return(2) #renvoi numPiste = 2

29/09/2020, 08h36
wiztricks

Salut,

Si le signal a détecter est un carré qui dure T s., il faudrait pouvoir lire l'état des N pins dans un intervalle de temps "petit" devant T/N.

Ce qui veut dire qu'attente passage ne se contente pas de sortir quand il trouve un carré quelque part mais la liste des N états où au moins un est à 0.

Les threads ne vont rien apporter car avec Python, vous utiliserez au mieux un CPU: la lecture restera séquentielle avec en plus l'overhead du changement de thread par rapport à une lecture séquentielle.

Par contre, vous devriez pouvoir utiliser GPIO.add_event_detect... ou demander de l'aide dans un forum plus "hardware".

- W

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
def attentePassage():
    pistes = {1,2}
    while pistes:
        if 1 in pistes and GPIO.input(button1)==0: 
            pistes.remove(1)
            yield(1) #renvoi numPiste = 1
 
        if 2 in pistes and GPIO.input(button2)==0:
            pistes.remove(2)
            yield(2) #renvoi numPiste = 2
 
for p in attentePassage():
    print(p)

Code:

1
2
3
4
5
6
7
8
def attentePassage():
    pistes = [1,2]
    while pistes:
        if 1 in pistes and GPIO.input(button1)==0: yield(pop(0))
        if 2 in pistes and GPIO.input(button2)==0: yield(pop(1))
 
for p in attentePassage():
    print(p)

29/09/2020, 10h01
tm68780

Bonjour
Merci pour la réponse de W

Pour les threads, ce que j’ai réussi à comprendre dans les docs me fait également penser que les threads ne m’apportent rien au niveau du temps de traitement.
Pour ce traitement j’ai 2 tâches prioritaires : la détection de la voiture (attentePassage) et le calcul du temps au tour (calculTempsTour).

L’affichage reste secondaire. Je pensais qu’il y aurait éventuellement une solution avec une pile (identification et temps) mais avec 2 threads le problème serait probablement l’accès à cette pile.
Un thread en écriture et l’autre en lecture/écriture.
Pour ce qui est du traitement des interruptions, tel que je le connais sur le GPIO, je ne gagne rien au niveau du temps de traitement, mais c’est vrai que la détection du front montant du signal est plus appropriée pour le passage d’une voiture au ralenti (signal pas trop long qui ne peux pas être détecté 2 fois).
29/09/2020, 10h05
tm68780

Merci Josmiley pour la réponse

J'ai regardé vite fait et je crois que c'est une bonne solution.
Je vais prendre le temps de regarder ça
29/09/2020, 11h08
wiztricks

Salut,

Citation:

Envoyé par tm68780

(signal pas trop long qui ne peux pas être détecté 2 fois).

C'est pour çà que l'approche séquentielle doit être "au pire" lire les N ports et retourner ou pas la liste de l'état de chaque port si l'un d'entre eux (ou plusieurs) est passé à 0.
note: si détecte un port qui est passé à 0, puis on le traite et on retourne voir s'il y a un autre port à traiter ajoute du délai entre 2 lectures successives (et encore plus si on repart à lire la séquence de tous les ports).

Citation:

Envoyé par tm68780

la détection du front montant du signal est plus appropriée pour le passage d’une voiture au ralenti (signal pas trop long qui ne peux pas être détecté 2 fois).

Le problème du polling est qu'on bouffe déjà un CPU pour scanner l'état des ports. On va pouvoir réaliser N scans par secondes et détecter une transition plus grande que 1/N secondes d'un facteur k.

Si vous associez un callback à la détection d'une transition, vous pouvez gérer autrement la contrainte CPU: le callback se contentant d'ajouter un évènement à traiter dans une pile/liste/Queue.

- W
29/09/2020, 15h16
tm68780

Salut Josmiley

Je crois que le code prend effectivement en compte toutes les détections (même très rapprochés) mais il ne fonctionne que si les voitures se suivent.
Si le 1 a un tour d'avance il ne sera pas compté.
29/09/2020, 15h35
josmiley

Citation:

Envoyé par tm68780

Salut Josmiley

Je crois que le code prend effectivement en compte toutes les détections (même très rapprochés) mais il ne fonctionne que si les voitures se suivent.
Si le 1 a un tour d'avance il ne sera pas compté.

donnes tout le code/détailles ton algo, pour avoir une vision plus globale de ce qui doit être fait.
29/09/2020, 15h50
tm68780

Merci pour ta réponse

Après un top départ chaque passage de voiture doit être comptabilisé et le temps au tour doit être calculé.
L'essentiel du code est donné dans mon premier message. Pour le reste l'affichage des temps, du nombre de tours, de la voiture en tête, du gagnant n'est que secondaire.

Comme tu l'as bien comprit la difficulté est de ne pas perdre de détection entre 2 "attentePassage() " et ça avec ton principe de pile c'est gagné...
29/09/2020, 16h12
josmiley

Citation:

Envoyé par tm68780

Merci pour ta réponse

Après un top départ chaque passage de voiture doit être comptabilisé et le temps au tour doit être calculé.
L'essentiel du code est donné dans mon premier message. Pour le reste l'affichage des temps, du nombre de tours, de la voiture en tête, du gagnant n'est que secondaire.

Comme tu l'as bien comprit la difficulté est de ne pas perdre de détection entre 2 "attentePassage() " et ça avec ton principe de pile c'est gagné...

ok, mais tu dis "...mais il ne fonctionne que si les voitures se suivent. Si le 1 a un tour d'avance il ne sera pas compté." Que se passe-t-il entre 2 tours ? sans plus de code je ne peux pas savoir.

J'ai fait tourner le code ci-dessous et je constate que:

Détection button1 --> repère 1 --> pistes = {2}
Détection button2 --> repère 2 --> pistes = {}
OK tout va bien

Détection button2 --> repère 2 --> pistes = {1}
Détection button1 --> repère 1 --> pistes = {}
OK tout va bien

Mais si:
Détection button1 --> repère 1 --> pistes = {2}
Détection button1 --> ni condition 1 ni condition 2
Code:

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 import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BOARD) #on utilise la numérotation pin physique button1=11 button2=12 GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP) GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP) def attentePassage(): pistes = {1,2} print ("Au debut ",pistes) while pistes: if 1 in pistes and GPIO.input(button1)==0: print ("niveau1 ",pistes) #repère 1 pistes.remove(1) print ("niveau1 bis ",pistes) yield(1) #renvoi numPiste = 1 if 2 in pistes and GPIO.input(button2)==0: print ("niveau2 ",pistes) #repère 2 pistes.remove(2) print ("niveau2 bis ",pistes) yield(2) #renvoi numPiste = 2 for p in attentePassage(): print(p)

haaa okkkk ... c'est pas une course. Je vois.
faut juste détecter le passage des tours. Je pense qu'il faut simuler un front montant/descendant. je te code ça et je poste ...

à tester:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
def attentePassage():
 
    bouton1state = 1
    bouton2state = 1
 
    while True:
 
        if GPIO.input(button1)!= bouton1state: 
            if bouton1state: yield(1) #renvoi numPiste = 1
            bouton1state = not bouton1state
 
        if GPIO.input(button2)!= bouton2state: 
            if bouton2state: yield(2) #renvoi numPiste = 2
            bouton2state = not bouton2state
 
for p in attentePassage():
    print(p)

29/09/2020, 17h16
tm68780

haaa okkkk ... c'est pas une course. Je vois.
faut juste détecter le passage des tours. Je pense qu'il faut simuler un front montant/descendant. je te code ça et je poste ...

Heu si :-)

Désolé j'ai du mal à m'exprimer. C'est bien une course avec un top départ, Puis entre ce top départ et un nombre de tour qu'on aura défini il faut comptabiliser le nombre de tours de chacun, les chronos, afficher qui est en-tête, et au final qui a gagné.

J'ai cherché du côté interuptions GPIO, mais lors d'une interruption sur front descendant il faut ensuite traiter cette interruption à savoir quel port est concerné et agir en conséquence.
Donc pour moi, avec mes quelques connaissances, ça ne change rien à la problématique. Il faut enregistrer le passage d'une voiture et son chrono dans une pile et de traiter cette pile pour l'affichage des infos lorsqu’on a le temps
29/09/2020, 17h20
josmiley

Citation:

Envoyé par tm68780

...Puis entre ce top départ et un nombre de tour qu'on aura défini il faut comptabiliser le nombre de tours de chacun, les chronos, afficher qui est en-tête, et au final qui a gagné....

la course s'arrête quand au moins une voiture a effectué N tours ou quand les 2 ont fait N tours ? c'est une variable que l'on peut intégrer au code et qui mettra fin à la boucle for.
29/09/2020, 17h26
tm68780

Vu qu'il n'y a que 2 voitures je dirais que la course est terminée lorsque au moins une voiture a effectué les N tours. mais ce n'est pas important.

Code:

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
def attentePassage(nbTours):
 
    bouton1state = 1
    nbTours1     = nbTours
    bouton2state = 1
    nbTours2     = nbTours
 
    while nbTours1 and nbTours2:
        #jusqu'à ce qu'au moins une voiture atteigne nbTours
        # remplacer par `while nbTours1 or nbTours2:` pour jusqu'à ce que les 2 voitures atteignent nbTours
 
        if GPIO.input(button1)!= bouton1state: 
            if nbTours1 and bouton1state:
                nbTours1 -= 1
                yield(1)
            bouton1state = not bouton1state
 
        if GPIO.input(button2)!= bouton2state: 
            if nbTours2 and bouton2state:
                nbTours2 -= 1
                yield(2)
            bouton2state = not bouton2state
 
for p in attentePassage(10):
    print(p)

29/09/2020, 17h41
tm68780

La question que je me pose:

Est-il possible de définir un thread comme prioritaire ou secondaire ?

Dans ce cas:
Le thread1 prioritaire serait chargé d'empiler les identifiants de pistes et les chronos
Le thread2 secondaire serait chargé de dépiler les infos pour les traiter mais que lorsque thread1 est inactif.
29/09/2020, 17h47
josmiley

Citation:

Envoyé par tm68780

La question que je me pose:

Est-il possible de définir un thread comme prioritaire ou secondaire ?

Dans ce cas:
Le thread1 prioritaire serait chargé d'empiler les identifiants de pistes et les chronos
Le thread2 secondaire serait chargé de dépiler les infos pour les traiter mais que lorsque thread1 est inactif.

le code que je t'ai donné devrait te permettre de te passer de thread, en général on peut s'en passer. Pour peu que le traitement soit plus rapide qu'un tour de circuit, tu devrais pouvoir faire tes calcules dans la boucle for.
29/09/2020, 17h48
tm68780

Oui ce dernier code fonctionne et répond bien.
Il faut que j'essaye de l'intégrer au reste avec le calcul chrono et l'affichage pour voir.

Mais ma dernière question reste ouverte :-)
29/09/2020, 17h51
tm68780

Heu non

Tu dis: Pour peu que le traitement soit plus rapide qu'un tour de circuit.

Je crois que c'est faux car ce serait "Pour peu que le traitement soit plus rapide que 2 détections successives" pour rappel voiture 2 passe la ligne en même temps ou presque.

Citation:

Envoyé par tm68780

Heu non

Tu dis: Pour peu que le traitement soit plus rapide qu'un tour de circuit.

Je crois que c'est faux car ce serait "Pour peu que le traitement soit plus rapide que 2 détections successives" pour rappel voiture 2 passe la ligne en même temps ou presque.

vrai ! mais pas vraiment, en fait c'est plus rapide qu'un état bas. Imaginons que les 2 voitures passent la ligne exactement en même temps, attentePassage doit reprendre la main avant le retour à l'état haut de la 2eme voiture.
l'idéal est de déclencher une interruption à chaque passage qui empilerait les données. Le programme principale les dépilerait, pas besoin de thread.

Je pense qu'il doit y avoir moyen de contourner ça, je réfléchis.

théoriquement, dans le code suivant, attentePassage ne yield que si aucune voiture n'est en train de passer la ligne. C'est une amélioration, mais ça change pas le problème, le traitement doit être plus court que le temps d'un état bas dans le cas où les 2 voitures se suivent de très très très près, sans néanmoins passer la ligne en même temps.
Code:

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 def attentePassage(nbTours): bouton1state = 1 nbTours1 = nbTours bouton2state = 1 nbTours2 = nbTours passage = [] while nbTours1 and nbTours2: #jusqu'à ce qu'au moins une voiture atteigne nbTours # remplacer par `while nbTours1 or nbTours2:` pour jusqu'à ce que les 2 voitures atteignent nbTours if GPIO.input(button1)!= bouton1state: if nbTours1 and bouton1state: nbTours1 -= 1 passage.append(1) bouton1state = not bouton1state continue if GPIO.input(button2)!= bouton2state: if nbTours2 and bouton2state: nbTours2 -= 1 passage.append(2) bouton2state = not bouton2state continue if bouton1state and bouton2state and passage: yield(passage.pop(0)) for p in attentePassage(10): print(p)

J'ai trouvé quelque chose

https://deusyss.developpez.com/tutor...Gpio/#LIII-B-9

La détection de front est quelque chose d'important, et liée aux interruptions. Il existe trois façons de procéder.
La première consiste à bloquer l'exécution du programme jusqu'à ce que l'événement se produise.
La seconde solution est liée à l'utilisation d'une boucle. On ajoute des événements à écouter sur un canal, et au sein de la boucle while, on teste si quelque chose s'est produit sur un des canaux écoutés.

Enfin, la dernière solution est celle qui est la plus proche du concept d'interruption sur microcontrôleur.
Pour ce faire, en cas d'événement, un thread parallèle est lancé en cas d'interruption. Trois valeurs sont possibles : front montant (GPIO.RISING), front descendant (GPIO.FALLING) ou bien les deux (GPIO.BOTH)).
Code:

1 2 3 4 5 6 Def my_callback(channel): print("un evenement s'est produit") #ici on ajoute une tempo de 75 ms pour eviter l'effet rebond GPIO.add_event_detect(channel, GPIO.BOTH, callback=my_callback, bouncetime=75) #votre programme ici

ça simplifie le code.

à tester:

Code:

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
from time import time
 
 
pile = []
 
boutonEvent = lambda numBouton: lambda : pile.append((numBouton,time()))
passage0 = boutonEvent(0)
passage1 = boutonEvent(1)
 
# ~ remplacer ici channel par les valeurs adequates 
GPIO.add_event_detect(channel, GPIO.FALLING, callback=passage0, bouncetime=75)
GPIO.add_event_detect(channel, GPIO.FALLING, callback=passage1, bouncetime=75)
 
def attentePassage(nbTours):
 
    tours = [nbTours,nbTours]
 
    while all(tours):
        #jusqu'à ce qu'au moins une voiture atteigne nbTours
        # remplacer par `while any(tours):` pour jusqu'à ce que les 2 voitures atteignent nbTours
 
        if pile:
            voiture,temps = pile.pop(0)
            if tours[voiture]:
                tours[voiture] -= 1
                yield((voiture,nbTours-tours[voiture],temps))
 
top = time()
for vt,tr,tm in attentePassage(10):
    print(f'voiture:{vt+1} tour:{tr} temps:{round(tm-top,4)}')

30/09/2020, 15h28
wiztricks

Salut,

Citation:

Envoyé par josmiley

ça simplifie le code.

Que le code marche ou pas, il serait plus intelligent de remplacer la simple liste par une queue.Queue et éviter de boucler sur while all(tours):.

- W

Citation:

Envoyé par wiztricks

... et éviter de boucler sur [B]while all(tours):

On est bien obligé de boucler sur quelque chose pour lire la queue, non ?

comme ça ?

Code:

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
from time import time
from queue import Queue
 
 
pile = Queue()
 
boutonEvent = lambda numBouton: lambda : pile.put((numBouton,time()))
passage0 = boutonEvent(0)
passage1 = boutonEvent(1)
 
# ~ remplacer ici channel par les valeurs adequates 
GPIO.add_event_detect(channel, GPIO.FALLING, callback=passage0, bouncetime=75)
GPIO.add_event_detect(channel, GPIO.FALLING, callback=passage1, bouncetime=75)
 
def attentePassage(nbTours):
 
    tours = [nbTours,nbTours]
 
    while all(tours):
        #jusqu'à ce qu'au moins une voiture atteigne nbTours
        # remplacer par `while any(tours):` pour jusqu'à ce que les 2 voitures atteignent nbTours
 
        voiture,temps = pile.get()
        if tours[voiture]:
            tours[voiture] -= 1
            yield((voiture,nbTours-tours[voiture],temps))
 
top = time()
for vt,tr,tm in attentePassage(10):
    print(f'voiture:{vt+1} tour:{tr} temps:{round(tm-top,4)}')

30/09/2020, 18h34
wiztricks

Citation:

Envoyé par josmiley

On est bien obligé de boucler sur quelque chose pour lire la queue, non ?

Ecrire une boucle pour attendre l'évènement suivant et le traiter ou "boucler" pour juste constater que la pile est vide et faire chauffer le CPU...

- W
30/09/2020, 19h53
tm68780

Merci Josmiley

Désolé je n'ai pas encore eu le temps de tester ton code et je n'ai pas encore terminé de tester le mien, pour l'instant j'ai quelques problèmes de rebond (avec des touches, ce qui est presque normal...). Il va falloir que j'essaye sur le circuit avec les détecteurs
30/09/2020, 20h02
tm68780

Pareil pour moi je n'ai pas trouvé d'autre solution que de boucler ... Mais bon, on a jamais fini d'apprendre

Par contre j'utilise: from collections import deque, ce qui me permet de faire du FIFO
01/10/2020, 11h06
wiztricks
Salut,

Citation:

Envoyé par tm68780

Pareil pour moi je n'ai pas trouvé d'autre solution que de boucler ... Mais bon, on a jamais fini d'apprendre

Si la condition est nombre de tours, on peut imaginer un callback passage qui décompte le nombre de tours et qui poste l'event "est arrivé" dans la "pile":
Code:

1 2 3 4 5 6 7 def passage(nButton, ntours=10): def _count(): nonlocal ntours ntours -= 1 if ntours <= 0: pile.put((nBouton,)) return _count
puis on a l'initialisation des callbacks:
Code:

1 2 for i in range(0): GPIO.add_event_detect(..., callback=passage(i)...)
Puis on attend que çà se termine:
Code:

1 2 n = pile.get()[-1] print (n, 'à gagné')
Le plus important là dedans étant le pile = queue.Queue() i.e. l'objet qui permet de ne pas boucler inutilement à attendre que çà se passe.

note: code non testé.

- W

pour Josmiley

J'ai essayé ton code qui me génère une erreur.
Avec mon petit niveau je ne comprends pas ton code :-)
Si tu as envie de chercher...

TypeError: <lambda>() takes 0 positional arguments but 1 was given

Code:

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
from time import time
from queue import Queue
import RPi.GPIO as GPIO 
 
GPIO.setmode(GPIO.BOARD) #on utilise la numérotation pin physique
button1=11
button2=12 
GPIO.setup(button1,GPIO.IN,pull_up_down=GPIO.PUD_UP)
GPIO.setup(button2,GPIO.IN,pull_up_down=GPIO.PUD_UP)
 
pile = Queue()
 
boutonEvent = lambda numBouton: lambda : pile.put((numBouton,time()))
passage0 = boutonEvent(0)
passage1 = boutonEvent(1)
 
# ~ remplacer ici channel par les valeurs adequates 
 
GPIO.add_event_detect(11, GPIO.FALLING, callback=passage0, bouncetime=75)
GPIO.add_event_detect(12, GPIO.FALLING, callback=passage1, bouncetime=75)
 
def attentePassage(nbTours):
 
    tours = [nbTours,nbTours]
 
    while all(tours):
        #jusqu'à ce qu'au moins une voiture atteigne nbTours
        # remplacer par `while any(tours):` pour jusqu'à ce que les 2 voitures atteignent nbTours
 
        voiture,temps = pile.get()
        if tours[voiture]:
            tours[voiture] -= 1
            yield((voiture,nbTours-tours[voiture],temps))
 
 
top = time()
 
 
for vt,tr,tm in attentePassage(10):
    print(f'voiture:{vt+1} tour:{tr} temps:{round(tm-top,4)}')

02/10/2020, 17h59
wiztricks

Salut,

Message d'erreur qui vous serait familier si vous aviez fait les exercices proposé dans n'importe quel tuto aux chapitres qui parlent des fonctions.

Çà dit juste que le callback sera appelé avec un paramètre (comme mentionné dans le tuto. que vous avez trouvé) et que la fonction correspondante doit avoir un argument...

Çà veut dire aussi que sans l'équipement pour "tester", difficile de vous donner un code qui marche, juste des idées à comprendre.

- W

effectivement, j'ai pas lu la doc, le callback prend un argument.
c'est corrigé.

Code:

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
from time import time
from queue import Queue
 
 
pile = Queue()
 
boutonEvent = lambda numBouton: lambda channel: pile.put((numBouton,time()))
 
# ~ remplacer ici channel par les valeurs adequates 
GPIO.add_event_detect(11, GPIO.FALLING, callback=boutonEvent(0), bouncetime=75)
GPIO.add_event_detect(12, GPIO.FALLING, callback=boutonEvent(1), bouncetime=75)
 
def attentePassage(nbTours):
 
    tours = [nbTours,nbTours]
 
    while all(tours):
        #jusqu'a ce qu'au moins une voiture atteigne nbTours
        # remplacer par `while any(tours):` pour jusqu'a ce que les 2 voitures atteignent nbTours
 
        voiture,temps = pile.get()
        if tours[voiture]:
            tours[voiture] -= 1
            yield((voiture,nbTours-tours[voiture],temps))
 
top = time()
for vt,tr,tm in attentePassage(10):
    print(f'voiture:{vt+1} tour:{tr} temps:{round(tm-top,4)}')

02/10/2020, 20h14
tm68780

Citation:

Envoyé par wiztricks

Salut,

Message d'erreur qui vous serait familier si vous aviez fait les exercices proposé dans n'importe quel tuto aux chapitres qui parlent des fonctions.

- W

Oui merci j'ai bien compris

Citation:

Envoyé par wiztricks

Salut,

Çà veut dire aussi que sans l'équipement pour "tester", difficile de vous donner un code qui marche, juste des idées à comprendre.

- W

Oui ça aussi c'est évident. Mais par politesse envers la personne qui m'a envoyé ce code, je devais l'informer du résultat...
02/10/2020, 20h54
josmiley

Citation:

Envoyé par wiztricks

Çà veut dire aussi que sans l'équipement pour "tester", difficile de vous donner un code qui marche, juste des idées à comprendre.

c'est le challenge ...
et c'est faisable, comme ici https://www.developpez.net/forums/d2...hon-raspberry/
06/10/2020, 16h41
tm68780

Salut Josmiley

Je n'ai pas encore étudié ton code, je suis occupé à revoir des bases :-)
mais j'ai essayé ton code, il affiche le cumul des chronos par pilote et non le chrono par tour du pilote
06/10/2020, 18h14
josmiley

Citation:

Envoyé par tm68780

Salut Josmiley

Je n'ai pas encore étudié ton code, je suis occupé à revoir des bases :-)
mais j'ai essayé ton code, il affiche le cumul des chronos par pilote et non le chrono par tour du pilote

Suffit de faire une soustraction d'un tour à l'autre.

Fuseau horaire GMT +2. Il est actuellement 07h44.