Boîte personnelle de Black - Arduino Mega, ultime bouclier GPS + LSM303 (3 / 4 étapes)

Étape 3: Arduino Mega + accéléromètre (LSM303)

Puis attacher le 5v et sol vers les emplacements appropriés. J’ai aussi réussi à utiliser un morceau d’anti mousse statique sous le dispositif avec un peu de colle chaud pour monter l’accéléromètre au Conseil d’administration de la GPS proto.

j’ai commencé avec la bibliothèque LSM303 de (https://github.com/pololu/lsm303-arduino). Ce paquet contient trois exemples, un dont, « Calibrer », j’ai fini par utiliser assez souvent. Cela a fonctionné pour moi, sans aucune modification et m’a permis de tester mon câblage. J’ai utilisé cela pour tirer les valeurs minimales et maximales pour l’accéléromètre x, y, x axe, ces valeurs serviront à équilibrer l’appareil lors du calcul de Forces-G.

G-Forces :
Pour calculer les G-Forces sur le LSM303, il suffit d’équilibrer les valeurs de l’accéléromètre et puis de les réduire. Je ne peux pas trouver le site où j’ai obtenu le code donc je m’excuse d’avance, mais j’espère avoir bientôt mis à jour.

Première ! Exécutez l’esquisse de calibrage de la bibliothèque de LSM303 pour obtenir votre x, y, z max et les valeurs min. Pour ce faire, maintenez votre LSM303 sur chacun des six axes et actualiser l’esquisse tenant toujours très. Vous ne voulez pas provoquer toute secoue vers le périphérique qui va secouer ses lectures, il m’a fallu plusieurs essais pour le faire enfin étalonné correctement.

Lorsque vous avez terminé, sur une surface plane, vous devriez obtenir une lecture comme ça (:: 0.00G, - 0.00G, 1.00G) où x et y sont 0 et z est 1. il n’est peut-être pas exact, mais il devrait flotter autour de ces chiffres.

#include < Wire.h >
#include < LSM303.h >

Compas de LSM303 ;
Ce sont mes valeurs, ils ne fonctionneront probablement pas pour vous
Exécutez l’esquisse de calibrage de la bibliothèque de LSM303 pour obtenir votre
les valeurs maximales et minimales pour x, y, z
int xRawMin =-16240 ;
int xRawMax = 15616 ;
int yRawMin =-17216 ;
int yRawMax = 16992 ;
int zRawMin =-14560 ;
int zRawMax = 18448 ;

void setup()
{
Serial.Begin(14400) ;
Wire.Begin() ;
Compass.init() ;
compass.enableDefault() ;
}

void loop()
{
Compass.Read() ;
long aimsthe desasters = compass.a.x ;
long yRaw = compass.a.y ;
long zRaw = compass.a.z ;

Convertir les valeurs brutes pour ' milli-Gs "
xScaled long = carte (aimsthe desasters, xRawMin, xRawMax, -1000, 1000) ;
yScaled long = carte (yRaw, yRawMin, yRawMax, -1000, 1000) ;
zScaled long = carte (zRaw, zRawMin, zRawMax, -1000, 1000) ;

ré-adapter à Gs fractionnaires
float xAccel = xScaled / 1000.0 ;
float yAccel = yScaled / 1000.0 ;
float zAccel = zScaled / 1000.0 ;

Serial.Print("::") ;
Serial.Print(xAccel) ;
Serial.Print (« G ») ;
Serial.Print(yAccel) ;
Serial.Print (« G ») ;
Serial.Print(zAccel) ;
Serial.println("G") ;

Delay(200) ;
}

Tangage et roulis :
J’ai trouvé un fil sur les forums arduino par « ArthurSpooner » pour le calcul de tangage et roulis, j’ai simplement modifié le code existant pour mon LSM303. Ajouter dans les bibliothèques et le programme d’installation de l’esquisse de l’étalonner, puis juste enlever de l’analogread et remplacez-le par votre compass.a.x.

Voici la version modifiée du code de Arnie que j’ai utilisé :
code par Arne
l’avait il mis en place la manière dont l’accélération z Regarde
au ciel, et x y est plat--> comme la plupart des systèmes de coordonnées cartésiennes
J’utilise un A7270 comme un accéléromètre -> ils sont sur une carte de dérivation pour environ 20 $ USD
et un HMC5843 comme un axe triple capteur magnétique 50 $ USD
n’hésitez pas à commenter le code -> amélioration est toujours apprécié
vous pouvez poser des questions en anglais ou en allemand

requis pour les calculs
#include < math.h >
#include < Wire.h >
#include < LSM303.h >
Compas de LSM303 ;
en augmentant l’alphaAccel la réponse deviendra plus rapide
mais le bruit va increae [alpha doit être comprise entre 0 et 1.]
valeurs de filtre passe-bas numérique
float alphaAccel = 0,4 ;
float alphaMagnet = 0,4 ;
unsigned int xOffset = 0 ; unsigned int Décalage_y = 0 ; unsigned int Décalage_z = 0 ;
flotteur hauteur = 0 ;
flotteur Roll = 0 ;
flotteur Yaw = 0 ;
aimsthe desasters int = 0 ; int yRaw = 0 ; int zRaw = 0 ;
float xFiltered = 0 ; float yFiltered = 0 ; float zFiltered = 0 ;
float xFilteredOld = 0 ; float yFilteredOld = 0 ; float zFilteredOld = 0 ;
float xAccel = 0 ; float yAccel = 0 ; float zAccel = 0 ;

void setup()
{
Serial.Begin(115200) ;       initialiser le port série
analogReference(EXTERNAL) ;  Utilisez la tension de référence externe (3, 3V)
Delay(2000) ;  calibrer le capteur après un court délai
Wire.Begin() ;
Compass.init() ;
compass.enableDefault() ;
getAccelOffset() ;           garder plat et non mobile sur la table
Il existe d’autres moyens pour calibrer l’offset, chacun a des avantages
et disadvantes...
comparer la note d’application AN3447
http://www.Freescale.com/files/sensors/doc/app_note/AN3447.pdf
}

Sub FilterAD()
{
lire AD et soustraire l’offset
xRaw=compass.a.x-Décalage_x ;
yRaw=compass.a.y-Décalage_y ;
zRaw=compass.a.z-Décalage_z ;
Numérique passe-bas - Comparez: (pour accéléromètre)
http://en.wikipedia.org/wiki/Low-pass_filter
xFiltered = xFilteredOld + alphaAccel * (aimsthe desasters - xFilteredOld) ;
yFiltered = yFilteredOld + alphaAccel * (yRaw - yFilteredOld) ;
zFiltered = zFilteredOld + alphaAccel * (zRaw - zFilteredOld) ;
xFilteredOld = xFiltered ;
yFilteredOld = yFiltered ;
zFilteredOld = zFiltered ;
}

Sub AD2Degree()
{
3.3 = Vref ; 1023 = 10bits AD ; 0,8 = sensibilité accéléromètre
(Comparez la fiche technique de votre accéléromètre)
le * Accel doit être comprise entre -1 et 1 ; vous devrez peut-être
pour ajouter/soustraire + 1 selon l’orientation de l’accéléromètre
(comme moi sur le zAccel)
ils ne sont pas nécessaires, mais sont utiles pour le débogage
xAccel = xFiltered * 3.3 / (1023.0 * 0,8) ;
yAccel = yFiltered * 3.3 / (1023.0 * 0,8) ;
zAccel = zFiltered * 3.3 / (1023.0 * 0,8) + 1.0 ;

Calculer de tangage et roulis (Comparez Application Note AN3461 de Freescale
http://www.Freescale.com/files/sensors/doc/app_note/AN3461.pdf
Microsoft Excel met les valeurs pour atan2
-> cette info peut vous faciliter la vie:-D
d’angle sont radian, degré (* 180/3.14159)
Rouleau = atan2 (yAccel, sqrt(sq(xAccel)+sq(zAccel))) ;
Hauteur = atan2 (xAccel, sqrt(sq(yAccel)+sq(zAccel))) ;
}

void loop()
{
Compass.Read() ;
FilterAD() ;
AD2Degree() ;
Serial.Print ("Pitch:") ;
Serial.Print(int(Pitch*180/pi)) ;
Serial.Print ("Roll:") ;
Serial.println(int(Roll*180/pi)) ;
Delay(50) ;
}

Sub getAccelOffset()
{//you peut faire environ 60 itérations car nous utilisons un unsigned int
dans le cas contraire, vous obtenez un dépassement de capacité. Mais 60 itérations devraient être bon
Compass.Read() ;
pour (int i = 1; i < = 60; i ++) {}
Décalage_x += compass.a.x ;
Décalage_y += compass.a.y ;
Décalage_z += compass.a.z ;
}
Décalage_x / = 60 ;
Décalage_y / = 60 ;
Décalage_z / = 60 ;
Serial.Print ("Décalage_x:") ; Serial.Print(xoffset) ;
Serial.Print ("Décalage_y:") ; Serial.Print(yOffset) ;
Serial.Print ("Décalage_z:") ; Serial.println(zOffset) ;

}

Le code de ArthurSpooner aussi contient la boussole vers, cependant j’ai réussi à trouver ce code sur adafruit et a décidé d’utiliser leur au lieu de cela, j’ai essayé d’utiliser compass.heading() mais je n’ai pas des résultats précis :

Compass.Read() ;
mx int = compass.m.x ;
int ma = compass.m.y ;

flotteur Pi = 3.14159 ;
position de flotteur = (atan2(my,mx) * 180) / Pi ;
Normaliser 0-360
Si (rubrique < 0)
{
rubrique = 360 + intitulé ;
}
Serial.println(Heading) ;