Personliga Black Box - Arduino Mega + ultimata GPS Shield + LSM303 (3 / 4 steg)

Steg 3: Arduino Mega + Accelerometer (LSM303)

Sedan bifoga den 5v och marken till lämplig placering. Jag lyckades också använda en bit av anti statisk skum under enheten med lite varmt lim för att montera accelerometern till den GPS proto styrelse.

jag började med LSM303 biblioteket från (https://github.com/pololu/lsm303-arduino). Detta innehåller tre exempel, en som, "Kalibrera", jag slutade med ganska ofta. Detta fungerade för mig utan några ändringar och tillät mig att testa min kabeldragning. Jag använde detta för att dra de lägsta och högsta värdena för accelerometern x, y, x-axeln, dessa värden används för att balansera ut enheten vid beräkning av G-krafter.

G-krafter:
För att beräkna G-krafter på LSM303 har vi bara att balansera ut accelerometer värdena och sedan skala dem. Jag kan inte hitta platsen där jag först fick koden så jag ber om ursäkt i förväg men jag hoppas att snart ha som uppdaterats.

Först! Kör den kalibrera skissen från LSM303 bibliotek för att få din x, y, z max och min värden. För att göra det, håll din LSM303 på varje av de sex axlar och uppdatera skissen håller den fortfarande mycket. Du vill inte orsaka någon skakar till enheten som som kommer att kasta bort sin avläsningar, detta tog mig flera försök att äntligen få den kalibrerad korrekt.

När du är klar, på en plan yta bör du få en behandling som denna (:: 0.00G, -0.00G, 1.00G) där x och y är 0 och z är 1. det kanske inte exakt men det borde flyta runt dessa nummer.

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

LSM303 kompass;
dessa är mina värden, de kommer troligtvis inte att fungera för dig
kör den kalibrera skissen från LSM303 biblioteket att få din
högsta och lägsta värden för 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();
lång xRaw = compass.a.x;
lång yRaw = compass.a.y;
lång zRaw = compass.a.z;

Konvertera raw-värden till "milli-Gs"
lång xScaled = karta (xRaw, xRawMin, xRawMax,-1000, 1000);
lång yScaled = karta (yRaw, yRawMin, yRawMax,-1000, 1000);
lång zScaled = karta (zRaw, zRawMin, zRawMax,-1000, 1000);

Re skala fraktionerad GS
flyta xAccel = xScaled / 1000.0;
flyta yAccel = yScaled / 1000.0;
flyta 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);
}

Pitch och rulla:
Jag hittade en tråd på arduino forum av "ArthurSpooner" för att beräkna Pitch och rulla, jag bara ändrade den befintliga koden för min LSM303. Lägg till i bibliotek och installationsprogrammet från kalibrera skiss, sedan bara bort analogread och ersätta den med din compass.a.x.

Här är den modifierade versionen av arnies kod som jag använde:
kod av Arne
acclerometer den inställd på sätt som z accelerationen ser ut
till himlen och x y är platt -> som de flesta cartesian koordinerat system
Jag använder en A7270 som en Accelerometer -> de är på en utbrytning styrelse för ca $20 USD
och en HMC5843 som en trippel axel magnetisk Sensor $50 USD
Känn dig fri att kommentera koden -> förbättring är alltid uppskattat
Du kan ställa frågor på engelska eller tyska

krävs för beräkningar
#include < math.h >
#include < Wire.h >
#include < LSM303.h >
LSM303 kompass;
genom att öka alphaAccel kommer svaret bli snabbare
men ljudet kommer increae [alpha måste vara mellan 0 och 1]
värden för digital variabelt
flyta alphaAccel = 0,4;
flyta alphaMagnet = 0,4;
unsigned int xOffset = 0; unsigned int yOffset = 0; unsigned int zOffset = 0;
flyta Pitch = 0;
flyta rulle = 0;
flyta Yaw = 0;
int xRaw = 0; int yRaw = 0; int zRaw = 0;
flyta xFiltered = 0; flyta yFiltered = 0; flyta zFiltered = 0;
flyta xFilteredOld = 0; flyta yFilteredOld = 0; flyta zFilteredOld = 0;
flyta xAccel = 0; flyta yAccel = 0; flyta zAccel = 0;

void setup()
{
Serial.BEGIN(115200); initiera serieporten
analogReference(EXTERNAL); använda extern referens spänning (3, 3V)
Delay(2000); kalibrera sensorn efter en kort fördröjning
Wire.BEGIN();
Compass.init();
compass.enableDefault();
getAccelOffset(); hålla den platt och icke rörliga på bordet
Det finns andra sätt att kalibrera förskjutningen har varje några advantes
och disadvantes...
jämföra applikationen noterar AN3447
http://www.Freescale.com/files/sensors/doc/app_note/AN3447.pdf
}

void FilterAD()
{
läsa från AD och subtrahera offset
xRaw=compass.a.x-xOffset;
yRaw=compass.a.y-yOffset;
zRaw=compass.a.z-zOffset;
Digital Low Pass - jämför: (för accelerometer)
http://en.wikipedia.org/wiki/low-pass_filter
xFiltered = xFilteredOld + alphaAccel * (xRaw - xFilteredOld);
yFiltered = yFilteredOld + alphaAccel * (yRaw - yFilteredOld);
zFiltered = zFilteredOld + alphaAccel * (zRaw - zFilteredOld);
xFilteredOld = xFiltered;
yFilteredOld = yFiltered;
zFilteredOld = zFiltered;
}

void AD2Degree()
{
3.3 = Vref; 1023 = 10 bitars AD; 0,8 = känslighet Accelerometer
(jämför datablad för din accelerometer)
den * Accel måste vara mellan -1 och 1. Du kan behöva
att lägga till/dra ifrån + 1 beroende på inriktningen av accelerometern
(som jag på zAccel)
de är inte nödvändiga, men är användbara för felsökning
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;

Beräkna Pitch och rulle (jämför ansökan Obs AN3461 från Freescale
http://www.Freescale.com/files/sensors/doc/app_note/AN3461.pdf
Microsoft Excel växlar värden för ARCTAN2
-> detta information kan göra ditt liv lättare :-D
vinklad är radian, för examen (* 180/3.14159)
Rulle = ARCTAN2 (yAccel, sqrt(sq(xAccel)+sq(zAccel)));
Pitch = ARCTAN2 (xAccel, sqrt(sq(yAccel)+sq(zAccel)));
}

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

void getAccelOffset()
{//you kan göra ca 60 iterationer eftersom vi använder en unsigned int
annars får du ett dataspill. Men 60 iterationer ska vara bra
Compass.Read();
för (int jag = 1; jag < = 60; i ++) {
xOffset += compass.a.x;
yOffset += compass.a.y;
zOffset += compass.a.z;
}
xOffset = 60.
yOffset = 60.
zOffset = 60.
Serial.Print ("xOffset:"); Serial.Print(xOffset);
Serial.Print ("yOffset:"); Serial.Print(yOffset);
Serial.Print ("zOffset:"); Serial.println(zOffset);

}

Koden från ArthurSpooner också innehåller kompassen rubrik, men jag lyckades hitta denna kod på adafruit och beslutat att använda deras istället, jag försökt med compass.heading() men jag fick inte korrekta resultat:

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

flyta Pi = 3.14159;
float rubrik = (atan2(my,mx) * 180) / Pi;
Normalisera till 0-360
om (rubrik < 0)
{
rubrik = 360 + nummer.
}
Serial.println(Heading);