Discussion :

[tournette]

Bonjour,

J'ai un programme qui permet de lire les données provenant d'une communication bluetooth. Je récupère les données selon les protocoles définis dans la fonction "lecture".
La période de lecture est de l'ordre de 80 ms. Cela n'est pas très rapide... J'aimerai atteindre plutot les 20ms

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
89
90
91
92
93
#import des librairies
import serial
import numpy as np
from matplotlib import pyplot as plt
import time
import struct
 
ser = serial.Serial('com7', 115200) #ouverture du port série. Il faut appareiller au pc le boitier et vérifier le numéro du port
duree=10
 
AGyY=0 #Angle Gyroscope axe Y
AFcY=0 #Angle Filtre Complémentaire axe Y
delta_t=0 #pas de temps entre deux mesures (lecture sur le port série environ 0,04s) 
TabFiltreComp = [0] * 1000 #déclaration des tableaux de données
TabGyY=[0] * 1000 #tableau angle gyroscope axe Y
TabAcY=[0] * 1000 #tableau angle accéléromètre axe Y
TabAk=[0] * 1000 #tableau angle calculé Kalman
inc= [0] * 1000 #tableau incréments
i=0 #incrément temps de mesure
 
fig, ax = plt.subplots() #création du graphe
fig.canvas.draw()
 
#fonction lecture : renvoi l'accélération en mg (axes X et Z) et la vitesse en °/s (axe Y)
def lecture():
    ser.write(b'e') #demande reception message 'a,b,c,d,e' selon le protocole
    data = ser.read(10) #affectation à data du message renvoyé
    if len(data)==10: #on vérifie que le nombre d'octet correspond à la demande (voir protocole)
    #concaténation des octets
        Ax=(float(list(bytearray(data))[1]<<8)+float(list(bytearray(data))[0])) #accélération sur x
        Az=(float(list(bytearray(data))[3]<<8)+float(list(bytearray(data))[2])) #accélération sur z
        Gy=(float(list(bytearray(data))[5]<<8)+float(list(bytearray(data))[4])) #vitesse autour de y
        if Ax>32768: #test pour trouver le signe de l'accélération sur X
            Ax=(65520-Ax)/16
        else :
            Ax=(-Ax/16)
        if Az>32768: #test pour trouver le signe de l'accélération sur Z
            Az=(65520-Az)/16
        else :
            Az=(-Az/16)
        if Gy>32768: #test pour trouver le signe de la vitesse autour de Y
            Gy=(65535-Gy)*0.0175
        else :
            Gy=(-Gy*0.0175)
        Ak=-struct.unpack(">f", data[-4:])[0] #récupère les 4 derniers octets et conversion en decimal protocole IEEE; angle Kalman
    return (Ax,Az,Gy,Ak)
 
#fonction gyro: calcul de l'angle (axeY) issu de la mesure du gyroscope
def gyro(GyY,AGyY,delta_t):
    AGyY=((AGyY+float(GyY)*delta_t)) #intégration de la vitesse
    return (AGyY)
 
#fonction accel: calcul l'angle issu de le mesure de l'accéléromètre    
def accel(AcX,AcZ):
    AAcY=np.arctan(float(AcX)/float(AcZ))*180/np.pi #calcul de projection
    return (AAcY)
 
#fonction filtre_comp: calcul de l'angle filtré à partir des mesures de l'accéléromètre et du gyroscope    
def filtre_comp(AcX,AcZ,GyY,AFcY,delta_t):
    AFcY=0.9*(AFcY+float(GyY)*delta_t) + 0.1*np.arctan(float(AcX)/float(AcZ))*180/np.pi
    return (AFcY)
 
print("début d'acquisition")    
while (i<duree):
    try:
        t=time.time()
        AcX,AcZ,GyY,Ak=lecture()
        delta_t=(time.time()-t)
        print(delta_t) #affichage possible des données dans la console...
        #print(AcX,AcZ,GyY)
        AGyY=gyro(GyY,AGyY,delta_t)
        AAcY=accel(AcX,AcZ)
        AFcY=filtre_comp(AcX,AcZ,GyY,AFcY,delta_t)
        TabGyY.append(AGyY) #on complète au fur et à mesure les données dans les tableaux
        TabAcY.append(AAcY)
        TabFiltreComp.append(AFcY)
        TabAk.append(Ak)
        inc.append(i)
        i=i+delta_t #incrément
 
    except:
        print("Oups!! problème...")
 
 
trace_filtre,=plt.plot(inc,TabFiltreComp, label="Filtre complémentaire") #affichage des tracés avec légendes
trace_gyr,=plt.plot(inc,TabGyY, label="Gyroscope")
trace_accel,=plt.plot(inc,TabAcY, label="Accéléromètre")
trace_kalman,=plt.plot(inc,TabAk, label="Filtre de Kalman")
plt.legend(handles=[trace_filtre,trace_gyr,trace_accel,trace_kalman], loc=4)
plt.show()
 
ser.close() #fermeture du port série
print("port série fermé :",ser.port)

Existe-t-il un moyen de diminuer cette période de lecture. Peut-être notamment sur la lecture des variables Ax, Az et Gy?

Cette durée est peut-être aussi tout simplement dû au temps d'écriture et de lecture sur le port série?

Merci d'avance pour vos réponses.

[wiztricks]

La période de lecture est de l'ordre de 80 ms. Cela n'est pas très rapide... J'aimerai atteindre plutot les 20ms

Vous ne pourrez pas aller plus vite que ce que le permet le port série et la latence de l'équipement à: réception d'une commande, fabrication de la réponse, transmission.

- W

[tournette]

Ok merci pour votre réponse. Je dois donc faire avec ce temps...

[wiztricks]

Ok merci pour votre réponse. Je dois donc faire avec ce temps...

Ben d'abord il faudrait mesurer le temps de l’échange, voir s'il y a des choses à faire côté équipement pour aller plus vite,... i.e. plutôt regarder l'ensemble que seulement le code Python.

- W