Compass module

What does the readings from the Seeed compass module look like?

How does the Seeed module cope with callibration?

I designed and built a 3D compass module, but it’s readings has HUGE offsets. Looks like there are both soft iron and hard iron offsets.

It doesn’t look like I can’t sell my 3D compass module, due to the callibration required before use, which ill be a pain to accomplish.

Code:


using System;
using Microsoft.SPOT;
using Gadgeteer.Modules.Seeed;

namespace CompassTest
{
    public partial class Program
    {
        // This method is run when the mainboard is powered up or reset.   
        void ProgramStarted()
        {
            compass.DebugPrintEnabled = true;
            compass.StartContinuousMeasurements();
            compass.MeasurementComplete += new Compass.MeasurementCompleteEventHandler(compass_MeasurementComplete);
            
        }

        void compass_MeasurementComplete(Compass sender, Compass.SensorData sensorData)
        {
            Debug.Print("Angle: " + sensorData.Angle + " X: " + sensorData.X + " Y: " + sensorData.Y + " Z: " + sensorData.Z);
        }
                
    }
}

Output:


Angle: 38.806091109993048 X: -115 Y: -143 Z: -449
Angle: 39.220510253349175 X: -111 Y: -136 Z: -447
Angle: 38.014385239779614 X: -111 Y: -142 Z: -448
Angle: 37.929651253701024 X: -113 Y: -145 Z: -449
Angle: 38.45370529259759 X: -108 Y: -136 Z: -447
Angle: 38.7580817295636 X: -114 Y: -142 Z: -450
Angle: 38.014385239779614 X: -111 Y: -142 Z: -448
Angle: 39.356677798393036 X: -114 Y: -139 Z: -448
Angle: 37.76307404719995 X: -110 Y: -142 Z: -445
Angle: 39.443957656066033 X: -116 Y: -141 Z: -448
Angle: 38.908482368637124 X: -113 Y: -140 Z: -451
Angle: 38.899936117140925 X: -117 Y: -145 Z: -449
Angle: 38.811380113920535 X: -111 Y: -138 Z: -448
Angle: 37.25528552450163 X: -108 Y: -142 Z: -450
Angle: 39.846087519117532 X: -116 Y: -139 Z: -451
Angle: 38.511880959594038 X: -113 Y: -142 Z: -447
Angle: 37.626229711253814 X: -111 Y: -144 Z: -447
Angle: 39.109369661947483 X: -113 Y: -139 Z: -448
Angle: 39.885982249059282 X: -117 Y: -140 Z: -447
Angle: 37.819460575684047 X: -111 Y: -143 Z: -448
Angle: 38.955903915408584 X: -114 Y: -141 Z: -447
Angle: 39.109369661947483 X: -113 Y: -139 Z: -447
Angle: 37.492649405049804 X: -112 Y: -146 Z: -448
Angle: 38.908482368637124 X: -113 Y: -140 Z: -447
Angle: 38.860313677405003 X: -112 Y: -139 Z: -452
Angle: 39.602247303177109 X: -115 Y: -139 Z: -448
Angle: 39.400656742540122 X: -115 Y: -140 Z: -449
Angle: 38.806091109993048 X: -115 Y: -143 Z: -447
Angle: 38.908482368637124 X: -113 Y: -140 Z: -449
Angle: 39.885982249059282 X: -117 Y: -140 Z: -449
Angle: 38.409387307578839 X: -111 Y: -140 Z: -446
Angle: 39.200778449344512 X: -115 Y: -141 Z: -445
Angle: 39.685450409951557 X: -117 Y: -141 Z: -447
Angle: 38.461033992957198 X: -112 Y: -141 Z: -450
Angle: 37.874979724732555 X: -112 Y: -144 Z: -446
Angle: 38.409387307578839 X: -111 Y: -140 Z: -450
Angle: 38.157222662136206 X: -110 Y: -140 Z: -447
Angle: 38.014385239779614 X: -111 Y: -142 Z: -448
Angle: 38.461033992957198 X: -112 Y: -141 Z: -452
Angle: 38.316131967343921 X: -113 Y: -143 Z: -446
Angle: 39.602247303177109 X: -115 Y: -139 Z: -449
Angle: 37.874979724732555 X: -112 Y: -144 Z: -445
Angle: 39.400656742540122 X: -115 Y: -140 Z: -450
Angle: 38.709325303453994 X: -113 Y: -141 Z: -450
Angle: 38.461033992957198 X: -112 Y: -141 Z: -448
Angle: 38.659804330725052 X: -112 Y: -140 Z: -446
Angle: 39.155430200912235 X: -114 Y: -140 Z: -450
Angle: 38.461033992957198 X: -112 Y: -141 Z: -447
Angle: 37.819460575684047 X: -111 Y: -143 Z: -448
Angle: 38.561946561287442 X: -114 Y: -143 Z: -447
Angle: 39.472455927620047 X: -112 Y: -136 Z: -446
Angle: 39.312004825527424 X: -113 Y: -138 Z: -448
Angle: 38.609500761809414 X: -111 Y: -139 Z: -445
Angle: 39.109369661947483 X: -113 Y: -139 Z: -449
Angle: 40.217463596850564 X: -115 Y: -136 Z: -447
Angle: 39.764406418320533 X: -114 Y: -137 Z: -451
Angle: 38.409387307578839 X: -111 Y: -140 Z: -447
Angle: 37.819460575684047 X: -111 Y: -143 Z: -448
Angle: 39.516405634942089 X: -113 Y: -137 Z: -448
Angle: 38.561946561287442 X: -114 Y: -143 Z: -448
Angle: 38.7580817295636 X: -114 Y: -142 Z: -447
Angle: 39.400656742540122 X: -115 Y: -140 Z: -447
Angle: 39.443957656066033 X: -116 Y: -141 Z: -449
Angle: 39.155430200912235 X: -114 Y: -140 Z: -448
Angle: 38.014385239779614 X: -111 Y: -142 Z: -448
Angle: 38.316131967343921 X: -113 Y: -143 Z: -447
Angle: 38.711144621387945 X: -109 Y: -136 Z: -451
Angle: 38.409387307578839 X: -111 Y: -140 Z: -449
Angle: 38.860313677405003 X: -112 Y: -139 Z: -449
Angle: 38.955903915408584 X: -114 Y: -141 Z: -445
Angle: 38.7580817295636 X: -114 Y: -142 Z: -447
Angle: 39.356677798393036 X: -114 Y: -139 Z: -446
Angle: 39.109369661947483 X: -113 Y: -139 Z: -449
Angle: 38.409387307578839 X: -111 Y: -140 Z: -445
Angle: 38.316131967343921 X: -113 Y: -143 Z: -447
Angle: 38.860313677405003 X: -112 Y: -139 Z: -449
Angle: 37.061731546467684 X: -108 Y: -143 Z: -451
Angle: 39.846087519117532 X: -116 Y: -139 Z: -448
Angle: 38.609500761809414 X: -111 Y: -139 Z: -451
Angle: 40.088207908486822 X: -117 Y: -139 Z: -447
Angle: 38.709325303453994 X: -113 Y: -141 Z: -448
Angle: 38.461033992957198 X: -112 Y: -141 Z: -446
Angle: 38.157222662136206 X: -110 Y: -140 Z: -450
Angle: 38.461033992957198 X: -112 Y: -141 Z: -448
Angle: 38.122061095677253 X: -113 Y: -144 Z: -450
Angle: 38.068639276102459 X: -112 Y: -143 Z: -451
Angle: 39.200778449344512 X: -115 Y: -141 Z: -448
Angle: 38.659804330725052 X: -112 Y: -140 Z: -449
Angle: 39.846087519117532 X: -116 Y: -139 Z: -447
Angle: 38.908482368637124 X: -113 Y: -140 Z: -446
Angle: 39.109369661947483 X: -113 Y: -139 Z: -448
Angle: 39.356677798393036 X: -114 Y: -139 Z: -446

Hope that helps!

1 Like

And if you rotate it through 360 degrees?

Hmm, did you have to calibrate it in anyway?

For some reason I thought the Seeed module was 2D.

Nope, I don’t see a method to calibrate it. I do see a SetGain method, but that’s the only thing even close to changing how it reads. I’ve posted the disassembled code for the driver below the readings.

It’s definitely 3D based on the values coming back below.

spinning 360 deg


Angle: 35.345018964821577 X: -200 Y: -282 Z: -423
Angle: 36.101093337599139 X: -202 Y: -277 Z: -420
Angle: 36.326822018378266 X: -200 Y: -272 Z: -421
Angle: 35.322644641921045 X: -197 Y: -278 Z: -423
Angle: 35.401948063848209 X: -199 Y: -280 Z: -422
Angle: 43.144410350404996 X: -224 Y: -239 Z: -424
Angle: 53.79305292952624 X: -265 Y: -194 Z: -416
Angle: 66.317908531848047 X: -285 Y: -125 Z: -421
Angle: 80.507802490645389 X: -311 Y: -52 Z: -410
Angle: 88.46736560049807 X: -299 Y: -8 Z: -415
Angle: 100.69650816414557 X: -270 Y: 51 Z: -424
Angle: 133.37885278074691 X: -109 Y: 103 Z: -460
Angle: 132.11703524001308 X: -146 Y: 132 Z: -444
Angle: 128.49437203767525 X: -127 Y: 101 Z: -458
Angle: 134.99999869634092 X: -121 Y: 121 Z: -454
Angle: 158.5522635034354 X: -44 Y: 112 Z: -465
Angle: 223.29864669628697 X: 98 Y: 104 Z: -455
Angle: 222.76052536291616 X: 86 Y: 93 Z: -461
Angle: 231.88642864951785 X: 116 Y: 91 Z: -451
Angle: 233.59122675820907 X: 80 Y: 59 Z: -467
Angle: 303.69007139656071 X: 30 Y: -20 Z: -484
Angle: 328.06932186330437 X: 43 Y: -69 Z: -485
Angle: 336.26207747852425 X: 73 Y: -166 Z: -477
Angle: 331.19797376210977 X: 138 Y: -251 Z: -447
Angle: 337.11936691491252 X: 92 Y: -218 Z: -463
Angle: 352.3039534747457 X: 35 Y: -259 Z: -458
Angle: 349.3221225047738 X: 56 Y: -297 Z: -444
Angle: 348.36637117265968 X: 63 Y: -306 Z: -440
Angle: 358.08505419826037 X: 11 Y: -329 Z: -434
Angle: 355.60129985287267 X: 20 Y: -260 Z: -459
Angle: 10.431368383315856 X: -44 Y: -239 Z: -466
Angle: 16.042777276233778 X: -67 Y: -233 Z: -466
Angle: 26.778836376495633 X: -108 Y: -214 Z: -464
Angle: 30.379122027903634 X: -119 Y: -203 Z: -460
Angle: 30.540600868041878 X: -118 Y: -200 Z: -466
Angle: 26.789295627994449 X: -103 Y: -204 Z: -467
Angle: 29.503506305471433 X: -116 Y: -205 Z: -463
Angle: 36.179616513427135 X: -147 Y: -201 Z: -460
Angle: 33.818241839445591 X: -138 Y: -206 Z: -459
Angle: 34.592284742934083 X: -140 Y: -203 Z: -460
Angle: 36.601949698760961 X: -153 Y: -206 Z: -456
Angle: 37.874979724732555 X: -161 Y: -207 Z: -455
Angle: 38.207295430455133 X: -159 Y: -202 Z: -457

rolling 360 deg


Angle: 178.12212255043187 X: -6 Y: 183 Z: -429
Angle: 180 X: 0 Y: 189 Z: -431
Angle: 178.4601617095413 X: -5 Y: 186 Z: -431
Angle: 176.56013030148614 X: -11 Y: 183 Z: -432
Angle: 176.68657459567243 X: -11 Y: 190 Z: -429
Angle: 193.61854172302529 X: 47 Y: 194 Z: -426
Angle: 221.91906541296299 X: 167 Y: 186 Z: -394
Angle: 241.38954173182861 X: 297 Y: 162 Z: -328
Angle: 247.60538777024829 X: 398 Y: 164 Z: -227
Angle: 252.78088644508003 X: 484 Y: 150 Z: -7
Angle: 252.59069975245069 X: 472 Y: 148 Z: 109
Angle: 257.26268500074229 X: 407 Y: 92 Z: 304
Angle: 251.89623945503337 X: 312 Y: 102 Z: 399
Angle: 237.84770621627464 X: 210 Y: 132 Z: 451
Angle: 206.56505235812617 X: 76 Y: 152 Z: 485
Angle: 167.96279763315624 X: -29 Y: 136 Z: 507
Angle: 153.79988398301788 X: -62 Y: 126 Z: 511
Angle: 132.36988602960253 X: -148 Y: 135 Z: 497
Angle: 123.3756029290326 X: -211 Y: 139 Z: 476
Angle: 122.64738651741618 X: -231 Y: 148 Z: 470
Angle: 118.81079234777874 X: -320 Y: 176 Z: 411
Angle: 115.86988733743047 X: -398 Y: 193 Z: 342
Angle: 111.12966431151273 X: -458 Y: 177 Z: 277
Angle: 104.01075348161625 X: -529 Y: 132 Z: 179
Angle: 102.04521519353349 X: -553 Y: 118 Z: 29
Angle: 103.62365242616355 X: -491 Y: 119 Z: -186
Angle: 102.84338851370329 X: -443 Y: 101 Z: -264
Angle: 104.73540896148974 X: -346 Y: 91 Z: -364
Angle: 107.35402213608464 X: -256 Y: 80 Z: -415
Angle: 113.41844897041291 X: -157 Y: 68 Z: -453
Angle: 134.11859469873744 X: -66 Y: 64 Z: -464
Angle: 169.07719524275157 X: -11 Y: 57 Z: -470
Angle: 194.03624353393064 X: 18 Y: 72 Z: -467
Angle: 217.349350330633 X: 58 Y: 76 Z: -461
Angle: 228.32740554994592 X: 91 Y: 81 Z: -452
Angle: 231.86369323262358 X: 121 Y: 95 Z: -446
Angle: 237.50342325232447 X: 146 Y: 93 Z: -437
Angle: 243.29787926582765 X: 167 Y: 84 Z: -434
Angle: 241.33604428681457 X: 150 Y: 82 Z: -442
Angle: 240.43047005241712 X: 141 Y: 80 Z: -442
Angle: 236.70643807645715 X: 134 Y: 88 Z: -442
Angle: 239.03624483758972 X: 135 Y: 81 Z: -446
Angle: 239.79676362322135 X: 134 Y: 78 Z: -447
Angle: 237.15091239205134 X: 127 Y: 82 Z: -449
Angle: 238.44286902026815 X: 127 Y: 78 Z: -448
Angle: 237.26477508004427 X: 126 Y: 81 Z: -445
Angle: 239.60982080574792 X: 133 Y: 78 Z: -443

flipping/looping 360 deg


Angle: 227.0213662464956 X: 132 Y: 123 Z: -432
Angle: 227.20259946816253 X: 135 Y: 125 Z: -431
Angle: 228.28924398664191 X: 138 Y: 123 Z: -433
Angle: 227.37695212105601 X: 138 Y: 127 Z: -431
Angle: 225.43405193629616 X: 133 Y: 131 Z: -428
Angle: 225.67403820242012 X: 129 Y: 126 Z: -431
Angle: 232.72182712178258 X: 134 Y: 102 Z: -441
Angle: 235.34868542483684 X: 136 Y: 94 Z: -441
Angle: 288.09390926901688 X: 101 Y: -33 Z: -474
Angle: 309.11401606709273 X: 214 Y: -174 Z: -430
Angle: 333.53690253602895 X: 224 Y: -450 Z: -293
Angle: 339.38720888734497 X: 208 Y: -553 Z: -173
Angle: 338.75419399270527 X: 229 Y: -589 Z: -2
Angle: 344.35775867280188 X: 168 Y: -600 Z: 107
Angle: 346.69476865015895 X: 140 Y: -592 Z: 194
Angle: 347.00538836740429 X: 126 Y: -546 Z: 290
Angle: 345.39873285653789 X: 124 Y: -476 Z: 363
Angle: 340.59103328737831 X: 136 Y: -386 Z: 428
Angle: 338.69422142963936 X: 117 Y: -300 Z: 476
Angle: 327.21931688228261 X: 123 Y: -191 Z: 506
Angle: 309.50767934420776 X: 114 Y: -94 Z: 522
Angle: 274.61065193325055 X: 124 Y: -10 Z: 516
Angle: 232.81529486885285 X: 145 Y: 110 Z: 479
Angle: 222.25738994261803 X: 159 Y: 175 Z: 451
Angle: 216.19669563945007 X: 191 Y: 261 Z: 382
Angle: 205.09153086836045 X: 177 Y: 378 Z: 267
Angle: 195.99583240258363 X: 129 Y: 450 Z: 151
Angle: 192.66892610688836 X: 107 Y: 476 Z: -23
Angle: 197.69794164420165 X: 142 Y: 445 Z: -113
Angle: 201.87915151402376 X: 153 Y: 381 Z: -229
Angle: 200.7963236400897 X: 109 Y: 287 Z: -353
Angle: 219.25771801545378 X: 161 Y: 197 Z: -387
Angle: 236.57125825447324 X: 203 Y: 134 Z: -400
Angle: 215.6214039670991 X: 139 Y: 194 Z: -402
Angle: 222.14854500918568 X: 124 Y: 137 Z: -425
Angle: 233.82038087925471 X: 134 Y: 98 Z: -439
Angle: 232.72661894077092 X: 113 Y: 86 Z: -445
Angle: 236.19204143307854 X: 112 Y: 75 Z: -449
Angle: 232.19923495772335 X: 107 Y: 83 Z: -447
Angle: 237.26477508004427 X: 126 Y: 81 Z: -444
Angle: 236.52372304968424 X: 124 Y: 82 Z: -445
Angle: 239.60982080574792 X: 133 Y: 78 Z: -443
Angle: 243.43495024919198 X: 146 Y: 73 Z: -441
Angle: 241.3610788527686 X: 141 Y: 77 Z: -441

Let me know if you need any more info or want to do a screen share/video to try certain maneuvers to see the results.

Diassembled module driver code:


// Generated by Reflector from C:\Program Files (x86)\Seeed\Seeed .NET Gadgeteer SDK\Modules\Compass\NETMF 4.2\GTM.Seeed.Compass.dll
namespace Gadgeteer.Modules.Seeed
{
    using Gadgeteer;
    using Gadgeteer.Interfaces;
    using Gadgeteer.Modules;
    using System;
    using System.Runtime.CompilerServices;
    
    public class Compass : Module
    {
        private MeasurementCompleteEventHandler _OnMeasurementComplete;
        private byte[] _readBuffer8 = new byte[1];
        private byte[] _writeBuffer16 = new byte[2];
        private byte[] _writeBuffer8 = new byte[1];
        private const double atan_p0 = 896.78594970703125;
        private const double atan_p1 = 1780.4063720703125;
        private const double atan_p2 = 1153.029296875;
        private const double atan_p3 = 268.42547607421875;
        private const double atan_p4 = 16.153640747070312;
        private const double atan_q0 = 896.78594970703125;
        private const double atan_q1 = 2079.3349609375;
        private const double atan_q2 = 1666.7838134765625;
        private const double atan_q3 = 536.265380859375;
        private const double atan_q4 = 58.95697021484375;
        private bool continuousMeasurement;
        private Timer continuousTimer;
        private InterruptInput dataReady;
        private I2CBus i2c;
        private MeasurementCompleteEventHandler MeasurementComplete;
        private const double pio2 = 1.5707963705062866;
        private const double pio4 = 0.78539818525314331;
        private byte[] readBuffer48 = new byte[6];
        private const double sq2m1 = 0.41421356797218323;
        private const double sq2p1 = 2.4142136573791504;
        
        public event MeasurementCompleteEventHandler MeasurementComplete _MeasurementComplete
        {
            [MethodImpl(MethodImplOptions.Synchronized)] add
            {
                this.MeasurementComplete = (MeasurementCompleteEventHandler) Delegate.Combine((Delegate) this.MeasurementComplete, (Delegate) value);
            }
            [MethodImpl(MethodImplOptions.Synchronized)] remove
            {
                this.MeasurementComplete = (MeasurementCompleteEventHandler) Delegate.Remove((Delegate) this.MeasurementComplete, (Delegate) value);
            }
        }
        
        public Compass(int socketNumber)
        {
            Socket socket = Socket.GetSocket(socketNumber, true, this, null);
            this.continuousTimer = new Timer(new TimeSpan(0, 0, 0, 0, 200));
            this.continuousTimer.Tick += new Timer.TickEventHandler(this.continuousTimer_Tick);
            this.i2c = new I2CBus(socket, 30, 100, this);
            this.dataReady = new InterruptInput(socket, Socket.Pin.Three, GlitchFilterMode.Off, ResistorMode.Disabled, InterruptMode.RisingEdge, this);
            this.dataReady.Interrupt += new InterruptInput.InterruptEventHandler(this.dataReady_Interrupt);
        }
        
        private double Atan2(double y, double x)
        {
            if ((x + y) == x)
            {
                if ((x == 0.0) & (y == 0.0))
                {
                    return 0.0;
                }
                if (x >= 0.0)
                {
                    return 1.5707963705062866;
                }
                return -1.5707963705062866;
            }
            if (y < 0.0)
            {
                if (x >= 0.0)
                {
                    return (3.1415927410125732 - this.Atans(-x / y));
                }
                return (-3.1415927410125732 + this.Atans(x / y));
            }
            if (x > 0.0)
            {
                return this.Atans(x / y);
            }
            return -this.Atans(-x / y);
        }
        
        private double Atans(double x)
        {
            if (x < 0.41421356797218323)
            {
                return this.Atanx(x);
            }
            if (x > 2.4142136573791504)
            {
                return (1.5707963705062866 - this.Atanx(1.0 / x));
            }
            return (0.78539818525314331 + this.Atanx((x - 1.0) / (x + 1.0)));
        }
        
        private double Atanx(double x)
        {
            double num = x * x;
            double num2 = (((((((16.153640747070312 * num) + 268.42547607421875) * num) + 1153.029296875) * num) + 1780.4063720703125) * num) + 896.78594970703125;
            num2 /= ((((((((num + 58.95697021484375) * num) + 536.265380859375) * num) + 1666.7838134765625) * num) + 2079.3349609375) * num) + 896.78594970703125;
            return (num2 * x);
        }
        
        private void continuousTimer_Tick(Timer timer)
        {
            if (!this.continuousMeasurement)
            {
                timer.Stop();
            }
            else
            {
                this.RequestMeasurement();
            }
        }
        
        private void dataReady_Interrupt(InterruptInput sender, bool value)
        {
            this.Read(Register.DXRA, this.readBuffer48);
            int x = (this.readBuffer48[0] << 8) | this.readBuffer48[1];
            int z = (this.readBuffer48[2] << 8) | this.readBuffer48[3];
            int y = (this.readBuffer48[4] << 8) | this.readBuffer48[5];
            x = (((x >> 15) == 1) ? -32767 : 0) + (x & 0x7fff);
            z = (((z >> 15) == 1) ? -32767 : 0) + (z & 0x7fff);
            y = (((y >> 15) == 1) ? -32767 : 0) + (y & 0x7fff);
            if (((x == -4096) || (y == -4096)) || (z == -4096))
            {
                base.DebugPrint("Invalid data read. Measurement discarded.");
            }
            else
            {
                double angle = (this.Atan2((double) y, (double) x) * 57.295779578552292) + 180.0;
                SensorData sensorData = new SensorData(angle, x, y, z);
                this.OnMeasurementCompleteEvent(this, sensorData);
            }
        }
        
        protected virtual void OnMeasurementCompleteEvent(Compass sender, SensorData sensorData)
        {
            if (this._OnMeasurementComplete == null)
            {
                this._OnMeasurementComplete = new MeasurementCompleteEventHandler(this.OnMeasurementCompleteEvent);
            }
            if (Program.CheckAndInvoke((Delegate) this.MeasurementComplete, (Delegate) this._OnMeasurementComplete, new object[] { sender, sensorData }))
            {
                this.MeasurementComplete(sender, sensorData);
            }
        }
        
        private void Read(Register register, byte[] readBuffer)
        {
            this._writeBuffer8[0] = (byte) register;
            this.i2c.WriteRead(this._writeBuffer8, readBuffer, 0x3e8);
        }
        
        private byte ReadByte(Register register)
        {
            this._writeBuffer8[0] = (byte) register;
            this.i2c.WriteRead(this._writeBuffer8, this._readBuffer8, 0x3e8);
            return this._readBuffer8[0];
        }
        
        public void RequestMeasurement()
        {
            this.i2c.Write(new byte[] { 2, 1 }, 100);
        }
        
        public void SetGain(Gain gain)
        {
            this.Write(Register.CRB, (byte) gain);
        }
        
        public void StartContinuousMeasurements()
        {
            this.continuousMeasurement = true;
            this.continuousTimer.Start();
        }
        
        public void StopContinuousMeasurements()
        {
            this.continuousMeasurement = false;
            this.continuousTimer.Stop();
        }
        
        private void Write(Register register, byte value)
        {
            this._writeBuffer16[0] = (byte) register;
            this._writeBuffer16[1] = value;
            this.i2c.Write(this._writeBuffer16, 0x3e8);
        }
        
        public TimeSpan ContinuousMeasurementInterval
        {
            get
            {
                return this.continuousTimer.Interval;
            }
            set
            {
                this.continuousTimer.Stop();
                this.continuousTimer.Interval = value;
                if (this.continuousMeasurement)
                {
                    this.continuousTimer.Start();
                }
            }
        }
        
        public enum Gain : byte
        {
            Gain1 = 0,
            Gain2 = 0x20,
            Gain3 = 0x40,
            Gain4 = 0x60,
            Gain5 = 0x80,
            Gain6 = 160,
            Gain7 = 0xc0,
            Gain8 = 0xe0
        }
        
        public delegate void MeasurementCompleteEventHandler(Compass sender, Compass.SensorData sensorData);
        
        private enum Mode : byte
        {
            Continous = 0,
            IdleMode = 2,
            SingleMode = 1,
            SleepMode = 3
        }
        
        private enum Register : byte
        {
            CRA = 0,
            CRB = 1,
            DXRA = 3,
            DXRB = 4,
            DYRA = 7,
            DYRB = 8,
            DZRA = 5,
            DZRB = 6,
            IRA = 10,
            IRB = 11,
            IRC = 12,
            MR = 2,
            SR = 9
        }
        
        public class SensorData
        {
            private double <Angle>k__BackingField;
            private int <X>k__BackingField;
            private int <Y>k__BackingField;
            private int <Z>k__BackingField;
            
            public SensorData(double angle, int x, int y, int z)
            {
                this.Angle = angle;
                this.X = x;
                this.Y = y;
                this.Z = z;
            }
            
            public override string ToString()
            {
                return ("Angle: " + this.Angle.ToString("f2") + " X: " + this.X.ToString("f2") + " Y: " + this.Y.ToString("f2") + " Z: " + this.Z.ToString("f2"));
            }
            
            public double Angle
            {
                get
                {
                    return this.<Angle>k__BackingField;
                }
                private set
                {
                    this.<Angle>k__BackingField = value;
                }
            }
            
            public int X
            {
                get
                {
                    return this.<X>k__BackingField;
                }
                private set
                {
                    this.<X>k__BackingField = value;
                }
            }
            
            public int Y
            {
                get
                {
                    return this.<Y>k__BackingField;
                }
                private set
                {
                    this.<Y>k__BackingField = value;
                }
            }
            
            public int Z
            {
                get
                {
                    return this.<Z>k__BackingField;
                }
                private set
                {
                    this.<Z>k__BackingField = value;
                }
            }
        }
    }
}


1 Like

@ stevepresley - No real need to use reflector, the code is available on codeplex.

Codeplex SVN URL:
https://gadgeteer.svn.codeplex.com/svn/Main/Modules/Seeed/Compass/Software/Compass/Compass.cs

1 Like

Thanks Steve.

I guess there is then no point in going further with my module design, as I thought I was adding a 3D compass where there was onl a 2D compass available…

And they get better readings of their chip than I get off mine…

I didn’t realize the Seeed module code was up there in addition to the rest of the framework. I’ll know next time to point to the URL!

Cheers,
Steve

Anytime! And thanks for marking my reply as the answer :wink:

I actually didn’t realize the compass was 3D either - considering using it instead of a Gyro module on my rover if I can get similar enough data - brings the price down around 75% per module - and some of my rovers will need 2!

Yeah, the Seeed driver give heading, but it can theoretically give heading and pitch, and yaw, except when one axis points directly north(similar to gimbal lock).