Help with 5883L crazyness.

Hi Joey,

I took your code and added ALG_TEST stuff to it and modifying the declinationAngle variable:

//#include "heading.h"
#include <stdio.h>
#include <iostream>


//#include <wiringPi.h>
//#include <wiringPiI2C.h>
#include <math.h>


using namespace std;


// comment out the next line if there is a WiringPi library
#define NO_WIRING


#define SENSORS_GAUSS_TO_MICROTESLA       (100)
#define     PI 3.1415926535897932384626433832795
#define HEADINGADDRESS          0x1e
#define HEADINGDEADBAND 2
#define ALG_TEST 1




static float _hmc5883_Gauss_LSB_XY = 1100.0F;
static float _hmc5883_Gauss_LSB_Z  = 980.0F;






class Heading
{
  public:
  int memsBoard;
  int address;
  float fx,fy,fz;
  short int x,y,z;
  float currentHeading,previousHeading;


  Heading(int address);
  int Initialize();
  float GetHeading();
  bool HeadingReached(double);

};




Heading::Heading(int address)
{
  this->address = address;
}




int Heading::Initialize()
{
  cout << "HEADING INIT here" << endl;
  int t;
  if (ALG_TEST)
  {
  cout << "Heading::Initialize()" << endl;
  return(0);
  }


#ifndef NO_WIRING
  memsBoard = wiringPiI2CSetup(address);
  t = wiringPiI2CWriteReg8(memsBoard,0x02,0x00);
  if(memsBoard < 0)
  return memsBoard;


  if(t < 0)
  return t;


  t = wiringPiI2CWriteReg8(memsBoard,0x01,0x20);
  if(t < 0)
  return t;
#endif
  return 0;

}




float CorrectHeading(float heading)
{
  float _0to90 = -100;
  float _91to180 = -136;
  float _181to270 = -100;
  float _270to360 = 20;


  if(heading >=100 && heading <= 100+90)
  return heading + _0to90;


        if(heading >= 91 && heading <= 180)
                return  heading + _91to180;
        if(heading >=181 && heading <= 271)
                return  heading + _181to270;
        if(heading >=271 && heading <= 360)
                return  heading + _270to360;


  return heading;






}


float Heading::GetHeading()
{
  if (ALG_TEST)
  {
  cout << "Heading::GetHeading" << endl;
  x=-238; // this is 0xff12
  y=-342; // this is 0xfeaa
  z=-479; // this is 0xfe21


  }
#ifndef NO_WIRING
  x  = wiringPiI2CReadReg8(memsBoard,0x03) << 8;
        x |=   wiringPiI2CReadReg8(memsBoard,0x04);


  z = wiringPiI2CReadReg8(memsBoard,0x05) << 8;
        z |=   wiringPiI2CReadReg8(memsBoard,0x06);


  y =  wiringPiI2CReadReg8(memsBoard,0x07) << 8;
        y |=   wiringPiI2CReadReg8(memsBoard,0x08);
#endif
  fx = x;
  fy = y;
  fz = z;


  float heading = atan2(fy,fx);


        float declinationAngle = 0.0404; //0.22;
  heading += declinationAngle;
  if(heading < 0)
    heading += 2*PI;
  if(heading > 2*PI)
    heading -= 2*PI;


  previousHeading = currentHeading;
  currentHeading = heading * 180/M_PI;
  //currentHeading = CorrectHeading(currentHeading);


  return currentHeading;








}






bool Heading::HeadingReached(double heading)
{
        double b = GetHeading();
        if(fabs(b - heading) <= HEADINGDEADBAND)
                return true;
        else
                return false;
}


Heading *magHeading;


int
main(void)
{
  float heading;


  magHeading=new Heading(1);
  heading=magHeading->GetHeading();


  printf("Heading is %lf\n", heading);
  if (ALG_TEST)
  {
  printf("Expected value is 237.48\n");
  }
  return(0);
}

You can compile it on any Linux machine by saving it to a file (called say mag-test.c) and then typing g++ mag-test.c and then you can run it by typing ./a.out

This is the result I get:

Heading::GetHeading
Heading is 237.480469
Expected value is 237.48

So, the algorithm appears working (the code uses the values 0xff12, 0xfeaa and 0xfe21 for the x, y and z values it pretends to read from the sensor,

and expects the output to be around 237.48 because that was the value in the example on the web page I mentioned ( Creative Electronic!: Arduino: simple compass with HMC5883L + Library ).

So, if it doesn't work, then either the code on that site is giving incorrect values (it is a possibility, even though the author claims it works, we must never assume!),

or I2C values read are incorrect.

The latter could occur with faulty or long wiring perhaps, or faulty/counterfeit sensor IC/module for example.

shabaz  Sorry man I got side tracked.  I will be working on this today.  Thanks for your help, I'll post back.

So I am trying out the self test procedure found at

http://www51.honeywell.com/aero/common/documents/myaerospacecatalog-documents/Defense_Brochures-documents/HMC5883L_3-Axis_Digital_Compass_IC.pdf

I am trying to understand the procedure.  I am confused about step 2, it says that 0a0 sets a gain of 5?  that hex value is 160..

EDIT:  Nevermind I got this, the 3 MSB of the byte of that register are the gain.  So 160 is 10100000b so 101 is 5 

Also step 5, how many times do I loop or does it matter?

The other odd thing is the first step of the loop "Send 0x3D 0x06 (Read all 6 bytes)"  Am I suppose to read x,y and z the same way as when in normal mode, if so what does the send step do?

Finally, I get negative values, does it matter which way the sensor is oriented?

Thanks!

1. Write CRA (00) – send 0x3C 0x00 0x71 (8-average, 15 Hz default, positive self test measurement)

2. Write CRB (01) – send 0x3C 0x01 0xA0 (Gain=5)

3. Write Mode (02) – send 0x3C 0x02 0x00 (Continuous-measurement mode)

4. Wait 6 ms or monitor status register or DRDY hardware interrupt pin

5. Loop

Send 0x3D 0x06 (Read all 6 bytes. If gain is changed then this data set is using previous gain) Convert three 16-bit 2’s compliment hex values to decimal values and assign to X, Z, Y, respectively. Send 0x3C 0x03 (point to first data register 03) Wait about 67 ms (if 15 Hz rate) or monitor status register or DRDY hardware interrupt pin

End_loop

6. Check limits – If all 3 axes (X, Y, and Z) are within reasonable limits (243 to 575 for Gain=5, adjust these limits basing on the gain setting used. See an example below.) Then  All 3 axes pass positive self test  Write CRA (00) – send 0x3C 0x00 0x70 (Exit self test mode and this procedure) Else  If Gain<7 Write CRB (01) – send 0x3C 0x01 0x_0 (Increase gain setting and retry, skip the next data set) Else At least one axis did not pass positive self test Write CRA (00) – send 0x3C 0x00 0x70 (Exit self test mode and this procedure) End If

Below is an example of how to adjust the “positive self” test limits basing on the gain setting: 
1. If Gain = 6, self test limits are:  Low Limit = 243 * 330/390 = 206 High Limit = 575 * 330/390 = 487 
2. If Gain = 7, self test limits are:  Low Limit = 243 * 230/390 = 143 High Limit = 575 * 230/390 = 339

When I run this I get this output (the zeros are "Success writes"

0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
x: -546
y: 211
z: -130
0
0
x: -548
y: 212
z: -128
0
0

Here is the code I am using:

int main()
{
short int x, y , z;
        wiringPiSetup();
        //Setup I2C
        memsBoard = wiringPiI2CSetup(0x1e);
//Not needed was just expirmenting
        int memsBoardRead = wiringPiI2CSetup(0x3D);
        int memsBoardWrite = wiringPiI2CSetup(0x1C);

//exit self test in case
//cerr << wiringPiI2CWrite(memsBoard,0x3c) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x00) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x70) << endl;

//step 1 self test mode
//cerr << wiringPiI2CWrite(memsBoard,0x3c) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x00) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x71) << endl;
//step 2 set gain 192=6 (11000000)
//cerr << wiringPiI2CWrite(memsBoard,0x3c) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x01) << endl;
cerr << wiringPiI2CWrite(memsBoard,192) << endl;

//step 3 set continuous mode
//cerr << wiringPiI2CWrite(memsBoard,0x3c) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x01) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x02) << endl;
usleep(10000);
while(1)
{
//step 5a loop 1
//cerr << wiringPiI2CWrite(memsBoard,0x03d) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x06) << endl;  //Not sure what this does
        x  = wiringPiI2CReadReg8(memsBoard,0x03) << 8;
        x |=   wiringPiI2CReadReg8(memsBoard,0x04);
        z = wiringPiI2CReadReg8(memsBoard,0x05) << 8;
        z |=   wiringPiI2CReadReg8(memsBoard,0x06);
        y =  wiringPiI2CReadReg8(memsBoard,0x07) << 8;
        y |=   wiringPiI2CReadReg8(memsBoard,0x08);
//step 5b       loop 2
//cerr<< wiringPiI2CWrite(memsBoard,0x3c) << endl;
cerr << wiringPiI2CWrite(memsBoard,0x3) << endl;  ///point to register X MSB, not needed
cout << "x: " << x << endl;
cout << "y: " << y << endl;
cout << "z: " << z << endl;
usleep(79000);
}

Been trying real hard to calibrate the compass, the self test don't make sense to me

This document here:

http://www.jameco.com/Jameco/Products/ProdDS/2150248.pdf

is WAY different than the current version of the spec sheet Honeywell provides.  So I am going to go over it and come back.  I am almost ready to just use some source code from Ardupilot and use the calibration code there.  I am not fond of cheating though.