Utilisez le «module de capteur 9 axes MPU-9250 (numéro de pièce du fabricant: MPU-9250)» fabriqué par Strawberry Linux avec Rasberry pi 3.
Il s'agit d'un record de lutte pour l'utilisation du "module de capteur 9 axes MPU-9250 (numéro de pièce du fabricant: MPU-9250)" fabriqué par Strawberry Linux avec Raspberry pi 3. J'essaye avec Python2.
Je ne pense pas que j'aurai plus le temps après la fin de GW J'ai acheté un capteur à l'âge adulte, mais il était presque intact. Je me sens comme un élève du primaire le dernier jour des vacances d'été.
(C'est long parce que j'ai écrit le processus d'essais et d'erreurs tel qu'il est. Je veux le résumer un jour.)
2017-04-09 Téléchargé sur github. https://github.com/boyaki-machine/MPU-9250
Câblage physique
Souder la tête de broche au capteur qui est arrivé. Puis fil.
Capteur 1pin (VDD) -> Raspi pin 1 Capteur 2 broches (VDDIO) -> Raspi broche 1 Capteur 3 broches (SCL) -> Raspi 5ème broche Capteur 4 broches (SDA) -> Raspi pin 3 Capteur 5 broches (GND ou VDD) -> Raspi pin 6 (l'adresse I2C change en fonction de GND ou VDD) Capteur 6 broches (VDDIO) -> Raspi pin 1 Capteur 10 broches (GND) -> Raspi 6ème broche
C'est désordonné, mais ça ressemble à ça.
Activer I2C avec Raspberry pi
Réglez dans le menu de configuration du système d'exploitation.
$ sudo raspi-config
Sélectionnez le menu dans l'ordre "9 Options avancées" -> "A7 I2C". Il vous sera demandé "Souhaitez-vous que l'interface ARM I2C soit activée?", Alors sélectionnez oui. On vous demandera "Souhaitez-vous que le module du noyau I2C soit chargé par défaut?", Alors sélectionnez oui.
Puis éditez /boot/config.txt.
$ sudo vi /boot/config.txt
...Ajout du contenu suivant
dtparam=i2c_arm=on
De plus, modifiez / etc / modules.
$ sudo vi /etc/modules
...Ajout du contenu suivant
snd-bcm2835
i2c-dev
Une fois les paramètres définis, redémarrez Raspy. Assurez-vous que le module du noyau est chargé après le redémarrage.
$ lsmod
...
i2c_dev 6709 0
snd_bcm2835 21342 0
...
Installer des outils
$ sudo apt-get install i2c-tools python-smbus
Confirmation d'adresse
Vérifiez l'adresse du capteur.
$ sudo i2cdetect -y 1 (Lorsque la broche 5 est connectée à GND)
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
Reconnu à l'adresse 0x68. Ce MPU-9250 possède un capteur magnétique intégré AK8963 fabriqué par Asahi Kasei Electronics. Dans l'état initial, AK8963 n'est pas accessible, mais il est accessible par I2C en manipulant certains registres. Définissez le registre avec le script python ci-dessous.
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import smbus
import time
address = 0x68
channel = 1
bus = smbus.SMBus(channel)
# PWR_MGMT_Effacer 1
bus.write_i2c_block_data(address, 0x6B, [0x00])
time.sleep(0.1)
#Fonction capteur magnétique avec I2C(AK8963)Accéder à(BYPASS_EN=1)
bus.write_i2c_block_data(address, 0x37, [0x02])
time.sleep(0.1)
Vérifiez à nouveau l'adresse après avoir exécuté le script.
$ sudo i2cdetect -y 1 (Lorsque la broche 5 est connectée à VDD)
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- 0c -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- 68 -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
AK8963 L'adresse 0x0C pour l'accès est affichée.
Obtenez une accélération
Obtenez des données brutes
Ici J'ai été autorisé à faire référence.
Selon la pièce jointe de Strawberry Linux
Au départ, il est en mode veille et aucune détection n'est effectuée. Tout d'abord, écrivez 0x00 à l'adresse interne 0x6B du MPU-9250. De plus, 0x02 est écrit à l'adresse interne 0x37. Cela démarrera l'opération et activera la communication I2C avec le capteur magnétique. Dans cet état, les données d'accélération X, Y, Z du gyroscope X, Y, Z sont stockées dans 14 octets à partir du registre interne 0x3B. Chaque donnée est de 16 bits et les 8 bits supérieurs sont alignés en premier. L'accélération est facile car vous pouvez déplacer le capteur pour voir l'accélération gravitationnelle. Le gyroscope doit être tourné, ce qui peut être un problème.
Pourquoi est-ce 14 octets alors que c'est 16 bits et 6 axes? Je me demandais, mais en regardant la fiche technique, il semble que la température puisse également être mesurée, qui est de 2 octets.
Pour l'instant, l'accélération de 6 octets est acquise et affichée.
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import smbus
import time
address = 0x68
bus = smbus.SMBus(channel)
#Réinitialiser le registre
bus.write_i2c_block_data(address, 0x6B, [0x80])
time.sleep(0.1)
# PWR_MGMT_Effacer 1
bus.write_i2c_block_data(address, 0x6B, [0x00])
time.sleep(0.1)
#Obtenez des données brutes
while True:
data = bus.read_i2c_block_data(address, 0x3B ,6)
rawX = data[0] << 8 | data[1] #Bit supérieur en premier
rawY = data[2] << 8 | data[3] #Bit supérieur en premier
rawZ = data[4] << 8 | data[5] #Bit supérieur en premier
print "%+8.7f" % rawX + " ",
print "%+8.7f" % rawY + " ",
print "%+8.7f" % rawZ
time.sleep(1)
Avec cela, nous avons pu confirmer que les données étaient sorties en continu.
Calculer g
Calculez l'accélération à partir des données brutes. Le réglage par défaut semble sortir dans la plage de ± 2g. Sur cette base, j'ai calculé comme suit. Cependant, la valeur affichée est étrange.
rawX = (2.0 / float(0x8000)) * (data[0] << 8 | data[1])
rawY = (2.0 / float(0x8000)) * (data[2] << 8 | data[3])
rawZ = (2.0 / float(0x8000)) * (data[4] << 8 | data[5])
print "%+8.7f" % rawX + " ",
print "%+8.7f" % rawY + " ",
print "%+8.7f" % rawZ
Selon diverses investigations, la valeur sortie par le capteur est de type non signé, il semble donc qu'il soit nécessaire de la convertir en type signé pour exprimer une valeur négative.
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import smbus
import time
address = 0x68
bus = smbus.SMBus(channel)
#Convertir non signé en signé(16 bits limité)
def u2s(unsigneddata):
if unsigneddata & (0x01 << 15) :
return -1 * ((unsigneddata ^ 0xffff) + 1)
return unsigneddata
#Réinitialiser le registre
bus.write_i2c_block_data(address, 0x6B, [0x80])
time.sleep(0.1)
# PWR_MGMT_Effacer 1
bus.write_i2c_block_data(address, 0x6B, [0x00])
time.sleep(0.1)
#Obtenez des données brutes
while True:
data = bus.read_i2c_block_data(address, 0x3B ,6)
rawX = (2.0 / float(0x8000)) * u2s(data[0] << 8 | data[1])
rawY = (2.0 / float(0x8000)) * u2s(data[2] << 8 | data[3])
rawZ = (2.0 / float(0x8000)) * u2s(data[4] << 8 | data[5])
print "%+8.7f" % rawX + " ",
print "%+8.7f" % rawY + " ",
print "%+8.7f" % rawZ
time.sleep(1)
Désormais, la direction de l'axe Z produit presque 1g.
Changer la plage de mesure
Lorsque vous faites pivoter le capteur, il atteint 2g de manière inattendue. Alors, changeons la plage de mesure. Selon la fiche technique, il semble que vous puissiez spécifier une plage de 2,4,8,16.
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import smbus
import time
address = 0x68
bus = smbus.SMBus(channel)
#Convertir non signé en signé(16 bits limité)
def u2s(unsigneddata):
if unsigneddata & (0x01 << 15) :
return -1 * ((unsigneddata ^ 0xffff) + 1)
return unsigneddata
#Réinitialiser le registre
bus.write_i2c_block_data(address, 0x6B, [0x80])
time.sleep(0.1)
# PWR_MGMT_Effacer 1
bus.write_i2c_block_data(address, 0x6B, [0x00])
time.sleep(0.1)
#Réglez la plage du capteur d'accélération sur ± 8g
bus.write_i2c_block_data(address, 0x1C, [0x08])
#Obtenez des données brutes
while True:
data = bus.read_i2c_block_data(address, 0x3B ,6)
rawX = (8.0 / float(0x8000)) * u2s(data[0] << 8 | data[1])
rawY = (8.0 / float(0x8000)) * u2s(data[2] << 8 | data[3])
rawZ = (8.0 / float(0x8000)) * u2s(data[4] << 8 | data[5])
print "%+8.7f" % rawX + " ",
print "%+8.7f" % rawY + " ",
print "%+8.7f" % rawZ
time.sleep(1)
Hmmm, maintenant vous pouvez obtenir la valeur même si vous vous balancez beaucoup.
Calibrer l'accélération
Selon la pièce jointe de Strawberry Linux
Comme il y a des variations dans le capteur, la valeur observée ne devient pas 0 même si l'accélération = 0 g, le gyroscope = 0 ° sec et le magnétisme = 0 μT, et les valeurs sont légèrement différentes. La plage de décalage autorisée est indiquée sur la feuille de données, la plage est donc normale. Il sera nécessaire que le logiciel fasse des ajustements en soustrayant le décalage.
Il y a. Certes, même si le capteur est fixe, l'accélération sur les axes X et Y ne sera pas nulle. Selon la fiche technique, il semble que vous puissiez définir la valeur de décalage sur le registre, mais essayez d'abord l'étalonnage côté python.
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import smbus
import time
address = 0x68
bus = smbus.SMBus(channel)
#Convertir non signé en signé(16 bits limité)
def u2s(unsigneddata):
if unsigneddata & (0x01 << 15) :
return -1 * ((unsigneddata ^ 0xffff) + 1)
return unsigneddata
#Réinitialiser le registre
bus.write_i2c_block_data(address, 0x6B, [0x80])
time.sleep(0.1)
# PWR_MGMT_Effacer 1
bus.write_i2c_block_data(address, 0x6B, [0x00])
time.sleep(0.1)
#Réglez la plage du capteur d'accélération sur ± 8g
bus.write_i2c_block_data(address, 0x1C, [0x08])
#Calculer la valeur d'étalonnage
print "Accel calibration start"
_sum = [0,0,0]
#Prenez un échantillon de données réelles
for _i in range(1000):
data = bus.read_i2c_block_data(address, 0x3B ,6)
_sum[0] += (8.0 / float(0x8000)) * u2s(data[0] << 8 | data[1])
_sum[1] += (8.0 / float(0x8000)) * u2s(data[2] << 8 | data[3])
_sum[2] += (8.0 / float(0x8000)) * u2s(data[4] << 8 | data[5])
#Décalage de la valeur moyenne
offsetAccelX = -1.0 * _sum[0] / 1000
offsetAccelY = -1.0 * _sum[1] / 1000
#L'axe Z soustrait la gravité, vraiment 1.0 est suspect
offsetAccelZ = -1.0 * ((_sum[2] / 1000 ) - 1.0)
print "Accel calibration complete"
#Obtenez des données brutes
while True:
data = bus.read_i2c_block_data(address, 0x3B ,6)
rawX = (8.0 / float(0x8000)) * u2s(data[0] << 8 | data[1]) + offsetAccelX
rawY = (8.0 / float(0x8000)) * u2s(data[2] << 8 | data[3]) + offsetAccelY
rawZ = (8.0 / float(0x8000)) * u2s(data[4] << 8 | data[5]) + offsetAccelZ
print "%+8.7f" % rawX + " ",
print "%+8.7f" % rawY + " ",
print "%+8.7f" % rawZ
time.sleep(1)
Hmmm, ce n'est pas exactement 0, mais c'est mieux qu'au début. Je ne sais pas si vous pouvez utiliser la valeur moyenne pour le décalage.
Autre
Même après l'étalonnage, si le capteur est fixe et qu'une détection continue est effectuée, la valeur continue de fluctuer légèrement. Détectez-vous une onde inconnue!? C'est effrayant. .. .. Peut-être que le capteur est trop sensible pour capter le bruit électrique. Il y avait "Réglage du filtre passe-bas de l'accéléromètre" dans la liste des registres de la fiche technique, donc si vous jouez avec cela, vous pouvez obtenir une valeur plus stable. Je n'y ai pas touché cette fois car le temps était écoulé.
Obtenez la température
Il semble que la température puisse être prise avec beaucoup d'efforts, alors je l'ai essayé.
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import smbus
import time
address = 0x68
bus = smbus.SMBus(channel)
#Réinitialiser le registre
bus.write_i2c_block_data(address, 0x6B, [0x80])
time.sleep(0.1)
# PWR_MGMT_Effacer 1
bus.write_i2c_block_data(address, 0x6B, [0x00])
time.sleep(0.1)
#Obtenez des données brutes
while True:
data = bus.read_i2c_block_data(address, 0x65 ,2)
raw = data[0] << 8 | data[1]
#La formule de calcul de la température est la suivante à partir de la fiche technique
# ((TEMP_OUT – RoomTemp_Offset)/Temp_Sensitivity) + 21degC
temp = (raw / 333.87) + 21
print str(temp)
Avec cela, la valeur qui semble être la température ambiante a été obtenue. La formule de calcul de la température à partir des données brutes est écrite dans la fiche technique, mais les valeurs essentielles de RoomTemp_Offset et Temp_Sensitivity ne sont pas répertoriées, donc [ici](https://ryusakura.wordpress.com/2015/04/ 23 / raspberrypie% E3% 81% A8mpu-9250% E3% 81% AE% E6% B8% A9% E5% BA% A6% E3% 82% BB% E3% 83% B3% E3% 82% B5 /) J'ai fait référence à l'article. Il semble que le suivi ne soit pas très bon et que la valeur ne change pas facilement même si vous la tenez avec votre main.
Obtenez une vitesse angulaire
Obtenez des données
La méthode est la même que pour l'accélération. Il calcule également les valeurs dps à partir des données brutes, corrige la plage de mesure et calcule les valeurs d'étalonnage.
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import smbus
import time
address = 0x68
bus = smbus.SMBus(1)
#Réinitialiser le registre
bus.write_i2c_block_data(address, 0x6B, [0x80])
time.sleep(0.1)
# PWR_MGMT_Effacer 1
bus.write_i2c_block_data(address, 0x6B, [0x00])
time.sleep(0.1)
#Corrigez la plage de mesure à 1000 dps
bus.write_i2c_block_data(address, 0x1B, [0x10])
#Facteur pour calculer les dps
gyroCoefficient = 1000 / float(0x8000)
#Calculer la valeur d'étalonnage
print "Gyro calibration start"
_sum = [0,0,0]
#Prenez un échantillon de données réelles
for _i in range(1000):
data = bus.read_i2c_block_data(address, 0x43 ,6)
_sum[0] += gyroCoefficient * u2s(data[0] << 8 | data[1])
_sum[1] += gyroCoefficient * u2s(data[2] << 8 | data[3])
_sum[2] += gyroCoefficient * u2s(data[4] << 8 | data[5])
#Décalage de la valeur moyenne
offsetGyroX = -1.0 * _sum[0] / 1000
offsetGyroY = -1.0 * _sum[1] / 1000
offsetGyroZ = -1.0 * _sum[2] / 1000
print "Gyro calibration complete"
#Obtenez des données
while True:
data = bus.read_i2c_block_data(address, 0x43 ,6)
rawX = gyroCoefficient * u2s(data[0] << 8 | data[1]) + offsetGyroX
rawY = gyroCoefficient * u2s(data[2] << 8 | data[3]) + offsetGyroY
rawZ = gyroCoefficient * u2s(data[4] << 8 | data[5]) + offsetGyroZ
print "%+8.7f" % rawX + " ",
print "%+8.7f" % rawY + " ",
print "%+8.7f" % rawZ + " "
time.sleep(1)
Autre
Comme pour le capteur d'accélération, la valeur dps fluctue même si le capteur est fixe. C'est juste une erreur vue à partir de la plage de mesure, mais cela ne semble pas s'installer. .. .. J'espère que cela pourra également être amélioré en définissant DLPF_CFG dans le registre 0x1A, mais je n'ai pas pu l'essayer cette fois.
Acquisition de capteur magnétique
Le capteur magnétique est AK8963 fabriqué par Asahi Kasei Electronics. J'apprécie vraiment la fiche technique japonaise. .. ..
C'est dommage, mais je pensais que le capteur était le seul fabricant japonais, mais même si j'ai vérifié le module d'échantillonnage connecté à raspi, il n'a été fabriqué qu'à l'étranger. Je veux que les fabricants japonais fassent de leur mieux.
Ainsi, avec l'AK8963, il est facile de prendre les données une seule fois, mais lorsque vous essayez d'effectuer une détection continue, diverses procédures sont gênantes. Je veux dire, c'est un design maniaque, ou vous pouvez faire des réglages étrangement détaillés. .. ..
Il existe quatre modes de mesure: simple coup, continu 1 (8 Hz), continu 2 (100 Hz) et déclenchement externe. De plus, le nombre de bits pour sortir la valeur mesurée peut être sélectionné en 16 bits / 14 bits. En mode de prise de vue unique, une fois la détection effectuée, il passera à la mise hors tension, vous devez donc redéfinir le mode de prise de vue unique. En particulier dans le mode de détection continue, les dernières (nouvelles) données sont supprimées jusqu'à ce que les données précédentes soient récupérées. Les données récupérées doivent être vérifiées à chaque fois pour détecter tout débordement. Il semble que la valeur correcte ne sortira pas si elle déborde.
De plus, j'étais accro au fait que les bits inférieurs peuvent être acquis en premier lors de la lecture des données du registre. Veuillez noter que le bit supérieur vient en premier pour l'accélération et la vitesse angulaire.
Avec ce sentiment, j'ai pensé essayer d'extraire uniquement la partie du capteur magnétique et de l'écrire, mais c'est assez difficile, alors veuillez lire l'opération classifiée.
Il est difficile de juger si le capteur magnétique est correct même si la valeur est obtenue. Selon wiki Il semble que "la force du géomagnétisme à 50 degrés de longitude: 58 μT", donc je ne pense pas que ce soit une valeur très différente.
Aussi, je voulais calculer l'orientation de chaque axe μT, mais je ne pouvais pas non plus le gérer. Est-ce la prochaine tâche?
Faites un cours ensemble
Classez les résultats jusqu'à présent ensemble.
#!/usr/bin/python -u
# -*- coding: utf-8 -*-
import smbus
import time
#MPU de Strawberry Linux-Classe pour obtenir des données de 9250 avec I2C(python 2)
# https://strawberry-linux.com/catalog/items?code=12250
#
# 2016-05-03 Boyaki Machine
class SL_MPU9250:
#Déclaration constante
REG_PWR_MGMT_1 = 0x6B
REG_INT_PIN_CFG = 0x37
REG_GYRO_CONFIG = 0x1B
REG_ACCEL_CONFIG1 = 0x1C
REG_ACCEL_CONFIG2 = 0x1D
MAG_MODE_POWERDOWN = 0 #Arrêt du capteur magnétique
MAG_MODE_SERIAL_1 = 1 #Capteur magnétique 8Hz mode de mesure continue
MAG_MODE_SERIAL_2 = 2 #Capteur magnétique 100 Hz mode de mesure continue
MAG_MODE_SINGLE = 3 #Mode de mesure en un seul coup avec capteur magnétique
MAG_MODE_EX_TRIGER = 4 #Mode de mesure de déclenchement externe du capteur magnétique
MAG_MODE_SELF_TEST = 5 #Mode d'auto-test du capteur magnétique
MAG_ACCESS = False #Accès au capteur magnétique
MAG_MODE = 0 #Mode capteur magnétique
MAG_BIT = 14 #Nombre de bits émis par le capteur magnétique
offsetRoomTemp = 0
tempSensitivity = 333.87
gyroRange = 250 # 'dps' 00:250, 01:500, 10:1000, 11:2000
accelRange = 2 # 'g' 00:±2, 01:±4, 10:±8, 11:±16
magRange = 4912 # 'μT'
offsetAccelX = 0.0
offsetAccelY = 0.0
offsetAccelZ = 0.0
offsetGyroX = 0.0
offsetGyroY = 0.0
offsetGyroZ = 0.0
#constructeur
def __init__(self, address, channel):
self.address = address
self.channel = channel
self.bus = smbus.SMBus(self.channel)
self.addrAK8963 = 0x0C
# Sensor initialization
self.resetRegister()
self.powerWakeUp()
self.gyroCoefficient = self.gyroRange / float(0x8000) #Un coefficient qui convertit la valeur décimale détectée en dps
self.accelCoefficient = self.accelRange / float(0x8000) #Un coefficient qui convertit la valeur décimale détectée en g
self.magCoefficient16 = self.magRange / 32760.0 #Un coefficient qui convertit la valeur décimale détectée en μT(À 16 bits)
self.magCoefficient14 = self.magRange / 8190.0 #Un coefficient qui convertit la valeur décimale détectée en μT(À 14 bits)
#Réinitialise les registres à leurs paramètres par défaut.
def resetRegister(self):
if self.MAG_ACCESS == True:
self.bus.write_i2c_block_data(self.addrAK8963, 0x0B, [0x01])
self.bus.write_i2c_block_data(self.address, 0x6B, [0x80])
self.MAG_ACCESS = False
time.sleep(0.1)
#Rend le registre mesurable.
def powerWakeUp(self):
# PWR_MGMT_Effacer 1
self.bus.write_i2c_block_data(self.address, self.REG_PWR_MGMT_1, [0x00])
time.sleep(0.1)
#Fonction capteur magnétique avec I2C(AK8963)Accéder à(BYPASS_EN=1)
self.bus.write_i2c_block_data(self.address, self.REG_INT_PIN_CFG, [0x02])
self.MAG_ACCESS = True
time.sleep(0.1)
#Réglez le registre du capteur magnétique
def setMagRegister(self, _mode, _bit):
if self.MAG_ACCESS == False:
#Soulevez une exception car l'accès au capteur magnétique n'est pas activé
raise Exception('001 Access to a sensor is invalid.')
_writeData = 0x00
#Réglage du mode de mesure
if _mode=='8Hz': #Mode de mesure continue 1
_writeData = 0x02
self.MAG_MODE = self.MAG_MODE_SERIAL_1
elif _mode=='100Hz': #Mode de mesure continue 2
_writeData = 0x06
self.MAG_MODE = self.MAG_MODE_SERIAL_2
elif _mode=='POWER_DOWN': #Mode de mise hors tension
_writeData = 0x00
self.MAG_MODE = self.MAG_MODE_POWERDOWN
elif _mode=='EX_TRIGER': #Mode de mesure de déclenchement externe
_writeData = 0x04
self.MAG_MODE = self.MAG_MODE_EX_TRIGER
elif _mode=='SELF_TEST': #Mode d'auto-test
_writeData = 0x08
self.MAG_MODE = self.MAG_MODE_SELF_TEST
else: # _mode='SINGLE' #Mode de mesure unique
_writeData = 0x01
self.MAG_MODE = self.MAG_MODE_SINGLE
#Nombre de bits à sortir
if _bit=='14bit': #Sortie 14 bits
_writeData = _writeData | 0x00
self.MAG_BIT = 14
else: # _bit='16bit' #Sortie 16 bits
_writeData = _writeData | 0x10
self.MAG_BIT = 16
self.bus.write_i2c_block_data(self.addrAK8963, 0x0A, [_writeData])
#Définit la plage de mesure de l'accélération. La granulométrie de mesure devient grossière dans une large plage.
# val = 16, 8, 4, 2(default)
def setAccelRange(self, val, _calibration=False):
# ±2g (00), ±4g (01), ±8g (10), ±16g (11)
if val==16 :
self.accelRange = 16
_data = 0x18
elif val==8 :
self.accelRange = 8
_data = 0x10
elif val==4 :
self.accelRange = 4
_data = 0x08
else:
self.accelRange = 2
_data = 0x00
self.bus.write_i2c_block_data(self.address, self.REG_ACCEL_CONFIG1, [_data])
self.accelCoefficient = self.accelRange / float(0x8000)
time.sleep(0.1)
#Réinitialiser la valeur de décalage(Pour empêcher l'héritage des valeurs de décalage passées)
self.offsetAccelX = 0
self.offsetAccelY = 0
self.offsetAccelZ = 0
#Je pense qu'il vaut mieux utiliser l'étalonnage, mais cela prend du temps.
if _calibration == True:
self.calibAccel(1000)
return
#Réglez la plage de mesure du gyroscope. La granulométrie de mesure devient grossière dans une large plage.
# val= 2000, 1000, 500, 250(default)
def setGyroRange(self, val, _calibration=False):
if val==2000:
self.gyroRange = 2000
_data = 0x18
elif val==1000:
self.gyroRange = 1000
_data = 0x10
elif val==500:
self.gyroRange = 500
_data = 0x08
else:
self.gyroRange = 250
_data = 0x00
self.bus.write_i2c_block_data(self.address, self.REG_GYRO_CONFIG, [_data])
self.gyroCoefficient = self.gyroRange / float(0x8000)
time.sleep(0.1)
#Réinitialiser la valeur de décalage(Pour empêcher l'héritage des valeurs de décalage passées)
self.offsetGyroX = 0
self.offsetGyroY = 0
self.offsetGyroZ = 0
#En fait, il est préférable d'utiliser l'étalonnage, mais cela prend du temps.
if _calibration == True:
self.calibGyro(1000)
return
#Réglez le filtre passe-bas du capteur d'accélération.
# def setAccelLowPassFilter(self,val):
#Si vous essayez d'utiliser les données du capteur telles quelles, elles seront traitées comme non signées, elles seront donc converties en signées.(16 bits limité)
def u2s(self,unsigneddata):
if unsigneddata & (0x01 << 15) :
return -1 * ((unsigneddata ^ 0xffff) + 1)
return unsigneddata
#Obtenez la valeur d'accélération
def getAccel(self):
data = self.bus.read_i2c_block_data(self.address, 0x3B ,6)
rawX = self.accelCoefficient * self.u2s(data[0] << 8 | data[1]) + self.offsetAccelX
rawY = self.accelCoefficient * self.u2s(data[2] << 8 | data[3]) + self.offsetAccelY
rawZ = self.accelCoefficient * self.u2s(data[4] << 8 | data[5]) + self.offsetAccelZ
return rawX, rawY, rawZ
#Obtenez la valeur du gyroscope.
def getGyro(self):
data = self.bus.read_i2c_block_data(self.address, 0x43 ,6)
rawX = self.gyroCoefficient * self.u2s(data[0] << 8 | data[1]) + self.offsetGyroX
rawY = self.gyroCoefficient * self.u2s(data[2] << 8 | data[3]) + self.offsetGyroY
rawZ = self.gyroCoefficient * self.u2s(data[4] << 8 | data[5]) + self.offsetGyroZ
return rawX, rawY, rawZ
def getMag(self):
if self.MAG_ACCESS == False:
#Le capteur magnétique n'est pas valide.
raise Exception('002 Access to a sensor is invalid.')
#Pré-traitement
if self.MAG_MODE==self.MAG_MODE_SINGLE:
#Le mode de mesure unique sera Power Down dès que la mesure est terminée, changez donc à nouveau de mode.
if self.MAG_BIT==14: #Sortie 14 bits
_writeData = 0x01
else: #Sortie 16 bits
_writeData = 0x11
self.bus.write_i2c_block_data(self.addrAK8963, 0x0A, [_writeData])
time.sleep(0.01)
elif self.MAG_MODE==self.MAG_MODE_SERIAL_1 or self.MAG_MODE==self.MAG_MODE_SERIAL_2:
status = self.bus.read_i2c_block_data(self.addrAK8963, 0x02 ,1)
if (status[0] & 0x02) == 0x02:
#Détecter à nouveau parce qu'il y a un dépassement de données
self.bus.read_i2c_block_data(self.addrAK8963, 0x09 ,1)
elif self.MAG_MODE==self.MAG_MODE_EX_TRIGER:
#Non mis en œuvre
return
elif self.MAG_MODE==self.MAG_MODE_POWERDOWN:
raise Exception('003 Mag sensor power down')
#Vérifiez le registre ST1 pour voir si les données peuvent être lues.
status = self.bus.read_i2c_block_data(self.addrAK8963, 0x02 ,1)
while (status[0] & 0x01) != 0x01:
#Attendez que les données soient prêtes
time.sleep(0.01)
status = self.bus.read_i2c_block_data(self.addrAK8963, 0x02 ,1)
#Lecture des données
data = self.bus.read_i2c_block_data(self.addrAK8963, 0x03 ,7)
rawX = self.u2s(data[1] << 8 | data[0]) #Bit inférieur en premier
rawY = self.u2s(data[3] << 8 | data[2]) #Bit inférieur en premier
rawZ = self.u2s(data[5] << 8 | data[4]) #Bit inférieur en premier
st2 = data[6]
#Contrôle de débordement
if (st2 & 0x08) == 0x08:
#La valeur correcte n'est pas obtenue en raison d'un débordement
raise Exception('004 Mag sensor over flow')
#Conversion en μT
if self.MAG_BIT==16: #En sortie 16 bits
rawX = rawX * self.magCoefficient16
rawY = rawY * self.magCoefficient16
rawZ = rawZ * self.magCoefficient16
else: #Au moment de la sortie 14 bits
rawX = rawX * self.magCoefficient14
rawY = rawY * self.magCoefficient14
rawZ = rawZ * self.magCoefficient14
return rawX, rawY, rawZ
def getTemp(self):
data = self.bus.read_i2c_block_data(self.address, 0x65 ,2)
raw = data[0] << 8 | data[1]
return ((raw - self.offsetRoomTemp) / self.tempSensitivity) + 21
def selfTestMag(self):
print "start mag sensor self test"
self.setMagRegister('SELF_TEST','16bit')
self.bus.write_i2c_block_data(self.addrAK8963, 0x0C, [0x40])
time.sleep(1.0)
data = self.getMag()
print data
self.bus.write_i2c_block_data(self.addrAK8963, 0x0C, [0x00])
self.setMagRegister('POWER_DOWN','16bit')
time.sleep(1.0)
print "end mag sensor self test"
return
#Calibrer le capteur d'accélération
#Je pense qu'il faut tenir compte de la latitude, de l'altitude, de la topographie, etc., mais c'est simple.
#En supposant que la gravité est appliquée correctement dans la direction de l'axe z et qu'aucune accélération autre que la gravité n'est générée
def calibAccel(self, _count=1000):
print "Accel calibration start"
_sum = [0,0,0]
#Prenez un échantillon de données réelles
for _i in range(_count):
_data = self.getAccel()
_sum[0] += _data[0]
_sum[1] += _data[1]
_sum[2] += _data[2]
#Décalage de la valeur moyenne
self.offsetAccelX = -1.0 * _sum[0] / _count
self.offsetAccelY = -1.0 * _sum[1] / _count
self.offsetAccelZ = -1.0 * ((_sum[2] / _count ) - 1.0) #Soustraire la gravité
#Je veux enregistrer la valeur de décalage dans le registre, mais je ne connais pas l'opération, donc la mise en œuvre est suspendue
print "Accel calibration complete"
return self.offsetAccelX, self.offsetAccelY, self.offsetAccelZ
#Calibrer le capteur gyroscopique
#Hypothèse selon laquelle la rotation ne se produit pas dans chaque axe
def calibGyro(self, _count=1000):
print "Gyro calibration start"
_sum = [0,0,0]
#Prenez un échantillon de données réelles
for _i in range(_count):
_data = self.getGyro()
_sum[0] += _data[0]
_sum[1] += _data[1]
_sum[2] += _data[2]
#Décalage de la valeur moyenne
self.offsetGyroX = -1.0 * _sum[0] / _count
self.offsetGyroY = -1.0 * _sum[1] / _count
self.offsetGyroZ = -1.0 * _sum[2] / _count
#Je veux enregistrer la valeur de décalage dans le registre, mais je ne connais pas l'opération, donc la mise en œuvre est suspendue
print "Gyro calibration complete"
return self.offsetGyroX, self.offsetGyroY, self.offsetGyroZ
if __name__ == "__main__":
sensor = SL_MPU9250(0x68,1)
sensor.resetRegister()
sensor.powerWakeUp()
sensor.setAccelRange(8,True)
sensor.setGyroRange(1000,True)
sensor.setMagRegister('100Hz','16bit')
# sensor.selfTestMag()
while True:
now = time.time()
acc = sensor.getAccel()
gyr = sensor.getGyro()
mag = sensor.getMag()
print "%+8.7f" % acc[0] + " ",
print "%+8.7f" % acc[1] + " ",
print "%+8.7f" % acc[2] + " ",
print " | ",
print "%+8.7f" % gyr[0] + " ",
print "%+8.7f" % gyr[1] + " ",
print "%+8.7f" % gyr[2] + " ",
print " | ",
print "%+8.7f" % mag[0] + " ",
print "%+8.7f" % mag[1] + " ",
print "%+8.7f" % mag[2]
sleepTime = 0.1 - (time.time() - now)
if sleepTime < 0.0:
continue
time.sleep(sleepTime)
Problèmes
Si vous utilisez la classe ci-dessus, vous pouvez obtenir les données en continu pour le moment. Cependant, afin de réaliser une détection plus précise, je pense qu'il est nécessaire d'utiliser le décalage attaché à la puce et la fonction de filtre passe-bas. J'aimerais l'essayer si j'ai le temps dans le futur.
Lorsque seules l'accélération et la vitesse angulaire étaient détectées en continu avec une source d'échantillon utilisant la classe ci-dessus, 100 Hz pouvait être atteint sans aucun problème, mais 200 Hz avaient tendance à être légèrement retardés. Je pense qu'il sera possible d'effectuer une détection avec une fréquence plus élevée en concevant également l'implémentation ici.
Vous ne vous souciez peut-être pas beaucoup de son utilisation avec raspi, mais si vous effectuez une détection avec une fréquence et une précision élevées, la consommation d'énergie augmentera, il est donc nécessaire de sélectionner un mode approprié en fonction de l'utilisation réelle. J'aimerais savoir quel mode consomme combien d'énergie .. Je me demande si cela prendra du temps alors ...
Si c'est utile, je suis heureux.
Recommended Posts