Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
Syntax
public class Mag3110 : ByteCommsSensorBase<(MagneticField3D? MagneticField3D, Temperature? Temperature)>, IObservable<IChangeResult<(MagneticField3D? MagneticField3D, Temperature? Temperature)>>, ISamplingSensor<(MagneticField3D? MagneticField3D, Temperature? Temperature)>, ISensor<(MagneticField3D? MagneticField3D, Temperature? Temperature)>, IDisposable, ITemperatureSensor, ISamplingSensor<Temperature>, ISensor<Temperature>, IMagnetometer, ISamplingSensor<MagneticField3D>, ISensor<MagneticField3D>, II2cPeripheral
Constructors
Mag3110(II2cBus, IDigitalInterruptPort?, byte)
Create a new MAG3110 object using the default parameters for the component
Declaration
public Mag3110(II2cBus i2cBus, IDigitalInterruptPort? interruptPort = null, byte address = 14)
Parameters
Type | Name | Description |
---|---|---|
II2cBus | i2cBus | I2C bus object - default = 400 KHz) |
IDigitalInterruptPort | interruptPort | Interrupt port used to detect end of conversions |
byte | address | Address of the MAG3110 (default = 0x0e) |
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
Fields
interruptPort
Interrupt port used to detect then end of a conversion
Declaration
protected readonly IDigitalInterruptPort? interruptPort
Field Value
Type | Description |
---|---|
IDigitalInterruptPort |
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
Properties
DefaultI2cAddress
The default I2C address for the peripheral
Declaration
public byte DefaultI2cAddress { get; }
Property Value
Type | Description |
---|---|
byte |
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
DigitalInputsEnabled
Enable or disable interrupts.
Declaration
public bool DigitalInputsEnabled { get; set; }
Property Value
Type | Description |
---|---|
bool |
Remarks
Interrupts can be triggered when a conversion completes (see section 4.2.5 of the datasheet). The interrupts are tied to the ZYXDR bit in the DR Status register.
IsDataReady
Indicate if there is any data ready for reading (x, y or z).
Declaration
public bool IsDataReady { get; }
Property Value
Type | Description |
---|---|
bool |
Remarks
See section 5.1.1 of the datasheet.
MagneticField3D
The current magnetic field value
Declaration
public MagneticField3D? MagneticField3D { get; }
Property Value
Type | Description |
---|---|
MagneticField3D? |
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
Standby
Change or get the standby status of the sensor
Declaration
public bool Standby { get; set; }
Property Value
Type | Description |
---|---|
bool |
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
Temperature
Current temperature of the die
Declaration
public Temperature? Temperature { get; }
Property Value
Type | Description |
---|---|
Temperature? |
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
Methods
RaiseEventsAndNotify(IChangeResult<(MagneticField3D? MagneticField3D, Temperature? Temperature)>)
Raise events for subscribers and notify of value changes
Declaration
protected override void RaiseEventsAndNotify(IChangeResult<(MagneticField3D? MagneticField3D, Temperature? Temperature)> changeResult)
Parameters
Type | Name | Description |
---|---|---|
IChangeResult<(MagneticField3D? MagneticField3D, Temperature? Temperature)> | changeResult | The updated sensor data |
Overrides
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
ReadSensor()
Reads data from the sensor
Declaration
protected override Task<(MagneticField3D? MagneticField3D, Temperature? Temperature)> ReadSensor()
Returns
Type | Description |
---|---|
Task<(MagneticField3D? MagneticField3D, Temperature? Temperature)> | The latest sensor reading |
Overrides
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
Reset()
Reset the sensor
Declaration
public void Reset()
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
Events
MagneticField3DUpdated
Raised when the magnetic field value changes
Declaration
public event EventHandler<IChangeResult<MagneticField3D>> MagneticField3DUpdated
Event Type
Type | Description |
---|---|
EventHandler<IChangeResult<MagneticField3D>> |
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |
TemperatureUpdated
Raised when the temperature value changes
Declaration
public event EventHandler<IChangeResult<Temperature>> TemperatureUpdated
Event Type
Type | Description |
---|---|
EventHandler<IChangeResult<Temperature>> |
Remarks
Mag3110 | |
---|---|
Status | |
Source code | GitHub |
Datasheet(s) | GitHub |
NuGet package |
The MAG3110 is a three axis magnetometer with an I2C interface. The magnetometer is capable of single and continuous readings.
Code Example
Mag3110 sensor;
public override Task Initialize()
{
Resolver.Log.Info("Initialize...");
sensor = new Mag3110(Device.CreateI2cBus());
// classical .NET events can be used
sensor.Updated += (sender, result) =>
{
Resolver.Log.Info($"Magnetic Field: [X:{result.New.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.New.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.New.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.New.Temperature?.Celsius:N2}C");
};
// Example that uses an IObservable subscription to only be notified when the filter is satisfied
var consumer = Mag3110.CreateObserver(
handler: result => Resolver.Log.Info($"Observer: [x] changed by threshold; new [x]: X:{result.New.MagneticField3D?.X.MicroTesla:N2}, old: X:{result.Old?.MagneticField3D?.X.MicroTesla:N2}"),
// only notify if there's a greater than 1 micro tesla on the Y axis
filter: result =>
{
if (result.Old is { } old)
{
return ((result.New.MagneticField3D - old.MagneticField3D)?.Y > new MagneticField(1, MU.MicroTesla));
}
return false;
});
sensor.Subscribe(consumer);
return Task.CompletedTask;
}
public async override Task Run()
{
var result = await sensor.Read();
Resolver.Log.Info("Initial Readings:");
Resolver.Log.Info($"Magnetic field: [X:{result.MagneticField3D?.X.MicroTesla:N2}," +
$"Y:{result.MagneticField3D?.Y.MicroTesla:N2}," +
$"Z:{result.MagneticField3D?.Z.MicroTesla:N2} (microTeslas)]");
Resolver.Log.Info($"Temp: {result.Temperature?.Celsius:N2}C");
sensor.StartUpdating(TimeSpan.FromMilliseconds(500));
}
Sample project(s) available on GitHub
Polling Mode
The following application reads the values from the magnetometer and displays the readings on the debug output:
public class MeadowApp : App<F7Micro, MeadowApp>
{
public MeadowApp()
{
Console.WriteLine("MAG3110 Test Application");
Mag3110 mag3110 = new Mag3110();
mag3110.Standby = false;
int readingCount = 0;
while (true)
{
mag3110.Read();
readingCount++;
Console.WriteLine(
"Reading " + readingCount.ToString() +
": x = " + mag3110.X.ToString() +
", y = " + mag3110.Y.ToString() +
", z = " + mag3110.Z.ToString());
Thread.Sleep(1000);
}
}
}
Wiring Example
In it's basic configuration the magnetometer requires four connections:
Meadow Pin | Sensor Pin | Wire Color |
---|---|---|
3.3V | Vcc | Red |
GND | GND | Black |
SC | SCK | Green |
SD | SDA | Blue |
D8 | INT1 | Orange |