/// <summary>
/// Initialisierung
/// </summary>
public async void InitAsync()
{
var settings = new I2cConnectionSettings((int)Address);
settings.BusSpeed = I2cBusSpeed.FastMode;
var controller = await I2cController.GetDefaultAsync();
Magnometer = controller.GetDevice(settings);
// First extract the factory calibration for each magnetometer axis
Magnometer.Write(new byte[] { (byte)Ak8963Register.CNTL, 0x00 }); // Power down magnetometer
Thread.Sleep(10);
Magnometer.Write(new byte[] { (byte)Ak8963Register.CNTL, 0x0F }); // Enter Fuse ROM access mode
Thread.Sleep(10);
Magnometer.Write(new byte[] { (byte)Ak8963Register.CNTL, 0x00 }); // Power down magnetometer
Thread.Sleep(10);
// Configure the magnetometer for continuous read and highest resolution
// set Mscale bit 4 to 1 (0) to enable 16 (14) bit resolution in CNTL register,
// and enable continuous mode data acquisition Mmode (bits [3:0]), 0010 for 8 Hz and 0110 for 100 Hz sample rates
Magnometer.Write(new byte[] { (byte)Ak8963Register.CNTL, MFS_16BITS << 4 | Mode }); // Set magnetometer data resolution and sample ODR
Thread.Sleep(10);
var whoAmI = new byte[1];
Magnometer.WriteRead(new byte[] { WHO_AM_I }, whoAmI); // Should return 0x48
WHO_AM_I_Address = BitConverter.ToString(whoAmI);
}
private async void InitializeSystem()
{
byte[] i2CWriteBuffer;
byte[] i2CReadBuffer;
byte bitMask;
var i2cSettings = new I2cConnectionSettings(PORT_EXPANDER_I2C_ADDRESS);
var controller = await I2cController.GetDefaultAsync();
i2cPortExpander = controller.GetDevice(i2cSettings);
// initialize I2C Port Expander registers
try
{
// initialize local copies of the IODIR, GPIO, and OLAT registers
i2CReadBuffer = new byte[1];
// read in each register value on register at a time (could do this all at once but
// for example clarity purposes we do it this way)
i2cPortExpander.WriteRead(new byte[] { PORT_EXPANDER_IODIR_REGISTER_ADDRESS }, i2CReadBuffer);
iodirRegister = i2CReadBuffer[0];
i2cPortExpander.WriteRead(new byte[] { PORT_EXPANDER_GPIO_REGISTER_ADDRESS }, i2CReadBuffer);
gpioRegister = i2CReadBuffer[0];
i2cPortExpander.WriteRead(new byte[] { PORT_EXPANDER_OLAT_REGISTER_ADDRESS }, i2CReadBuffer);
olatRegister = i2CReadBuffer[0];
// configure the LED pin output to be logic high, leave the other pins as they are.
olatRegister |= LED_GPIO_PIN;
i2CWriteBuffer = new byte[] { PORT_EXPANDER_OLAT_REGISTER_ADDRESS, olatRegister };
i2cPortExpander.Write(i2CWriteBuffer);
// configure only the LED pin to be an output and leave the other pins as they are.
// input is logic low, output is logic high
bitMask = (byte)(0xFF ^ LED_GPIO_PIN); // set the LED GPIO pin mask bit to '0', all other bits to '1'
iodirRegister &= bitMask;
i2CWriteBuffer = new byte[] { PORT_EXPANDER_IODIR_REGISTER_ADDRESS, iodirRegister };
i2cPortExpander.Write(i2CWriteBuffer);
}
catch (Exception e)
{
ButtonStatusText.Text = "Failed to initialize I2C port expander: " + e.Message;
return;
}
// setup our timers, one for the LED blink interval, the other for checking button status
ledTimer = new DispatcherTimer();
ledTimer.Interval = TimeSpan.FromMilliseconds(TIMER_INTERVAL);
ledTimer.Tick += LedTimer_Tick;
ledTimer.Start();
buttonStatusCheckTimer = new DispatcherTimer();
buttonStatusCheckTimer.Interval = TimeSpan.FromMilliseconds(BUTTON_STATUS_CHECK_TIMER_INTERVAL);
buttonStatusCheckTimer.Tick += ButtonStatusCheckTimer_Tick;
buttonStatusCheckTimer.Start();
}
public async Task InitAsync()
{
var controller = await I2cController.GetDefaultAsync();
if (controller == null)
{
throw new Exception("No I2C controller found");
}
htu21d = controller.GetDevice(new I2cConnectionSettings(Htu21dDefinitions.ADDRESS));
mpl3115a2 = controller.GetDevice(new I2cConnectionSettings(Mpl3115a2Definitions.ADDRESS));
if (htu21d == null || mpl3115a2 == null)
{
throw new Exception("Failed to open I2C device. Make sure the bus is not in use.");
}
int who_am_i_id;
try
{
who_am_i_id = WriteRead8(mpl3115a2, Mpl3115a2Definitions.WHO_AM_I);
}
catch (FileNotFoundException)
{
// First I2C operation might fail if some slave was in a bad state
who_am_i_id = WriteRead8(mpl3115a2, Mpl3115a2Definitions.WHO_AM_I);
}
if (who_am_i_id != Mpl3115a2Definitions.WHO_AM_I_ID)
{
throw new Exception("MP13115A2 fails WHO_AM_I test");
}
// 0x39 = barometer mode, oversampling of 128 samples, ACTIVE mode
// For a full list of flags, see page 33 of the datasheet
byte[] activateCmd = { Mpl3115a2Definitions.CTRL_REG1, 0x39 };
mpl3115a2.Write(activateCmd);
}
public async void InitMPUAsync()
{
var settings = new I2cConnectionSettings(DataMPU9150.MPU_I2C_ADDRESS);
settings.BusSpeed = I2cBusSpeed.FastMode;
var controller = await I2cController.GetDefaultAsync();
MPU = controller.GetDevice(settings);
if (MPU == null)
{
NotConnectedMessage = true;
}
else
{
try
{
Configuration();
ReadingData();
NotConnectedMessage = false;
}
catch (Exception)
{
NotConnectedMessage = true;
return;
}
}
}
/// <summary>
/// 初始化
/// </summary>
/// <returns></returns>
public async Task Initialize()
{
I2cController controller = await I2cController.GetDefaultAsync();
I2cConnectionSettings setting = new I2cConnectionSettings(Constants.Address)
{
BusSpeed = I2cBusSpeed.FastMode,
SharingMode = I2cSharingMode.Exclusive
};
MPU6050 = new I2CReadWrite(controller.GetDevice(setting));
await Task.Delay(3);
MPU6050.WriteByte(Constants.PwrMgmt1, 0x80); // reset the device
await Task.Delay(100);
MPU6050.WriteByte(Constants.PwrMgmt1, 0x2);
MPU6050.WriteByte(Constants.UserCtrl, 0x04); //reset fifo
MPU6050.WriteByte(Constants.PwrMgmt1, 1); // clock source = gyro x
MPU6050.WriteByte(Constants.GyroConfig, 0); // +/- 250 degrees sec
MPU6050.WriteByte(Constants.AccelConfig, 0); // +/- 2g
MPU6050.WriteByte(Constants.Config, 1); // 184 Hz, 2ms delay
MPU6050.WriteByte(Constants.SmplrtDiv, (byte)((1000 / SampleRate) - 1)); // set rate 50Hz
MPU6050.WriteByte(Constants.FifoEn, 0x78); // enable accel and gyro to read into fifo
MPU6050.WriteByte(Constants.UserCtrl, 0x40); // reset and enable fifo
MPU6050.WriteByte(Constants.IntEnable, 0x1);
MPU6050.WriteWord(Constants.XGyro_Offset, 0x00B5);
MPU6050.WriteWord(Constants.YGyro_Offset, 0xFFDF);
MPU6050.WriteWord(Constants.ZGyro_Offset, 0xFFE1);
}
static async void i2cget(string[] input)
{
if (input.Length == 3)
{
int slave = Convert.ToInt32(input[1], 16);
UpBridge.Up upb = new UpBridge.Up();
I2cController controller = await I2cController.GetDefaultAsync();
// Int32.TryParse(input[1], out slave);
I2cConnectionSettings Settings = new I2cConnectionSettings(slave);
byte[] writebuf = new byte[1];
writebuf[0] = Convert.ToByte(input[2], 16);
byte[] readbuf = new byte[1];
try
{
controller.GetDevice(Settings).WriteRead(writebuf, readbuf);
Console.WriteLine("Sucess to get data,\n" +
Convert.ToString(readbuf[0], 16));
}
catch (Exception e)
{
Console.WriteLine("error to get data\n");
}
}
else
{
Console.WriteLine("command error,plese refer to below example \n" +
"i2cget {i2c address} {i2c register}\n");
Console.WriteLine(Usage);
}
}
public async void InitializeIC2()
{
//Create an instance of I2cConnectionSettings, allowing to configure the I2c settings
I2cConnectionSettings settings = new I2cConnectionSettings(ACCEL_I2C_ADDR);
settings.BusSpeed = I2cBusSpeed.FastMode;
//Create and intance of I2cController with the I2cConnectingSettings
I2cController controller = await I2cController.GetDefaultAsync();
IC2Accele = controller.GetDevice(settings);
byte[] WriteBuf_DataFormat = new byte[] { ACCEL_REG_DATA_FORMAT, 0x01 }; /* 0x01 sets range to +- 4Gs*/
byte[] WriteBuf_PowerControl = new byte[] { ACCEL_REG_POWER_CONTROL, 0x08 }; /* 0x08 puts the accelerometer into measuremen*/
//Format the ADXL345
try
{
IC2Accele.Write(WriteBuf_DataFormat);
IC2Accele.Write(WriteBuf_PowerControl);
}
catch (Exception ex)
{
comfailed = "Failed to communicate with device" + ex.Message;
return;
}
}
int newI2Caddress = 28; // Pick a number between 0 and 127 that is not already on the I2C bus
public MainPage()
{
this.InitializeComponent();
viewModel = (MainViewModel)this.DataContext;
myProtractor = new Protractor(I2cController.GetDefaultAsync().GetResults(), 69, false);
PollProtractor();
}
private async Task InitI2c()
{
mods = new Dictionary <string, I2cDevice>();
foreach (var mod in game.RequiredMods)
{
var i2cSettings = new I2cConnectionSettings(mod.I2CAddress);
//i2cSettings.BusSpeed = I2cBusSpeed.FastMode;
var controller = await I2cController.GetDefaultAsync();
var device = controller.GetDevice(i2cSettings);
mods.Add(mod.Name, device);
foreach (var widget in mod.Widgets)
{
Buttons.Children.Add(new Ellipse
{
Name = mod.Name + "_" + widget.Name,
Fill = widget is DataModels.Button ? grayBrush : yellowBrush,
Stroke = whiteBrush,
Width = 20,
Height = 20,
Margin = new Thickness(10)
});
Buttons.Children.Add(new TextBlock
{
Name = mod.Name + "_" + widget.Name + "_Text",
FontSize = 10,
Margin = new Thickness(10)
});
}
}
}
private async Task ConnectToI2CDevices()
{
try {
string aqsFilter = I2cDevice.GetDeviceSelector("I2C1");
//DeviceInformationCollection collection = await DeviceInformation.FindAllAsync(aqsFilter);
//if (collection.Count == 0) {
// throw new SensorException("I2C device not found");
//}
if (LightningProvider.IsLightningEnabled)
{
// Set Lightning as the default provider
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
I2cConnectionSettings i2CSettings = new I2cConnectionSettings(_i2CAddress)
{
BusSpeed = I2cBusSpeed.FastMode
};
//_i2CDevice = await I2cDevice.FromIdAsync(collection[0].Id, i2CSettings);
I2cController controller = await I2cController.GetDefaultAsync();
if (controller == null)
{
throw new SensorException("I2C device not found");
}
_i2CDevice = controller.GetDevice(i2CSettings);
}
catch (Exception exception) {
throw new SensorException("Failed to connect to HTS221", exception);
}
}
public async Task Initialize()
{
var settings = new I2cConnectionSettings(I2C_ADDRESS)
{
BusSpeed = I2cBusSpeed.FastMode, SharingMode = I2cSharingMode.Shared
};
var controller = await I2cController.GetDefaultAsync();
_accelerometer = controller.GetDevice(settings);
QueuedLock.Enter();
//Enable all axes with normal mode
_accelerometer.Write(new byte[] { REGISTER_POWER_MANAGEMENT_1, 0 }); //Wake up device
_accelerometer.Write(new byte[] { REGISTER_POWER_MANAGEMENT_1, 0x80 }); //Reset the device
QueuedLock.Exit();
await Task.Delay(20);
QueuedLock.Enter();
_accelerometer.Write(new byte[] { REGISTER_POWER_MANAGEMENT_1, 1 }); //Set clock source to gyro x
_accelerometer.Write(new byte[] { REGISTER_GYROSCOPE_CONFIG, 0 }); //+/- 250 degrees sec
_accelerometer.Write(new byte[] { REGISTER_ACCELEROMETER_CONFIG, 0 }); //+/- 2g
_accelerometer.Write(new byte[] { REGISTER_CONFIG, 1 }); //184 Hz, 2ms delay
_accelerometer.Write(new byte[] { REGISTER_SAMPLE_RATE_DIVIDER, 19 }); //Set rate 50Hz
_accelerometer.Write(new byte[] { REGISTER_POWER_MANAGEMENT_1, 0 }); //Wake up device
QueuedLock.Exit();
}
private async Task Tml_Init(int irqPinNumber, int resetPinNumber)
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
GpioController gpio = GpioController.GetDefault();
pinIRQ = gpio.OpenPin(irqPinNumber);
pinRESET = gpio.OpenPin(resetPinNumber);
pinRESET.Write(GpioPinValue.High);
pinIRQ.SetDriveMode(GpioPinDriveMode.Input);
pinRESET.SetDriveMode(GpioPinDriveMode.Output);
I2cConnectionSettings settings = new I2cConnectionSettings(NXP_NCI_I2C_ADDR)
{
BusSpeed = I2cBusSpeed.FastMode,
SharingMode = I2cSharingMode.Shared
};
//string aqs = I2cDevice.GetDeviceSelector(I2C_CONTROLLER_NAME);
//DeviceInformationCollection dis = await DeviceInformation.FindAllAsync(aqs);
//i2c7120 = await I2cDevice.FromIdAsync(dis[0].Id, settings);
I2cController i2cController = await I2cController.GetDefaultAsync();
i2c7120 = i2cController.GetDevice(settings);
}
/**
* Start I2C Communication
**/
public async Task StartI2CAsync(byte deviceAddress, string controllerName = null)
{
try
{
var i2cSettings = new I2cConnectionSettings(deviceAddress);
i2cSettings.BusSpeed = I2cBusSpeed.FastMode;
if (string.IsNullOrEmpty(controllerName))
{
var controller = await I2cController.GetDefaultAsync();
_i2cPortExpander = controller.GetDevice(i2cSettings);
}
else
{
string deviceSelector = I2cDevice.GetDeviceSelector(controllerName);
var i2cDeviceControllers = await DeviceInformation.FindAllAsync(deviceSelector);
_i2cPortExpander = await I2cDevice.FromIdAsync(i2cDeviceControllers[0].Id, i2cSettings);
}
await InitializeAsync();
}
catch (Exception e)
{
Debug.WriteLine($"Exception: {e.Message}");
}
}
private async Task InitLCD()
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
var i2c = await I2cController.GetDefaultAsync();
if (i2c == null)
{
LCD = null;
return;
}
LCD = i2c.GetDevice(new I2cConnectionSettings(LCD_Addr));
//LCD初期化
await Task.Delay(50);
await WriteCmd(0x38, 1);
await WriteCmd(0x39, 1);
await WriteCmd(0x14, 1);
await WriteCmd(0x71, 1);
await WriteCmd(0x56, 1);
await WriteCmd(0x6c, 250);
await WriteCmd(0x38, 1);
await WriteCmd(0x0c, 1);
await WriteCmd(0x01, 200);
}
//==========================================================================
// GPIO Methods
//==========================================================================
//==========================================================================
// I2C Methods
//==========================================================================
//Initialise connection to I2C Device
public async void I2C_init()
{
I2cController controller = await I2cController.GetDefaultAsync();
tempSensor = controller.GetDevice(new I2cConnectionSettings(0x5C));
humiditySensor = controller.GetDevice(new I2cConnectionSettings(0x5F));
}
/// <summary>
///
/// </summary>
private async void InitSensor()
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
var i2c = await I2cController.GetDefaultAsync();
SENSOR = i2c.GetDevice(new I2cConnectionSettings(SensorAddr));
//SENSOR初期化
uint osrs_t = 3;
uint osrs_p = 3;
uint osrs_h = 3;
uint mode = 3;
uint t_sb = 5;
uint filter = 0;
uint spi3w_en = 0;
uint ctrlMeasReg = (osrs_t << 5) | (osrs_p << 2) | mode;
uint configReg = (t_sb << 5) | (filter << 2) | spi3w_en;
uint ctrlHumReg = osrs_h;
SENSOR.Write(new byte[] { 0xf2, (byte)ctrlHumReg });
SENSOR.Write(new byte[] { 0xf4, (byte)ctrlMeasReg });
SENSOR.Write(new byte[] { 0xf5, (byte)configReg });
await Task.Delay(10);
//キャリブレーションデータ読み込み
//温度
T1 = ReadUInt16((byte)Register.dig_T1);
T2 = (Int16)ReadUInt16((byte)Register.dig_T2);
T3 = (Int16)ReadUInt16((byte)Register.dig_T3);
//気圧
P1 = ReadUInt16((byte)Register.dig_P1);
P2 = (Int16)ReadUInt16((byte)Register.dig_P2);
P3 = (Int16)ReadUInt16((byte)Register.dig_P3);
P4 = (Int16)ReadUInt16((byte)Register.dig_P4);
P5 = (Int16)ReadUInt16((byte)Register.dig_P5);
P6 = (Int16)ReadUInt16((byte)Register.dig_P6);
P7 = (Int16)ReadUInt16((byte)Register.dig_P7);
P8 = (Int16)ReadUInt16((byte)Register.dig_P8);
P9 = (Int16)ReadUInt16((byte)Register.dig_P9);
//湿度
H1 = ReadByte((byte)Register.dig_H1);
H2 = (Int16)ReadUInt16((byte)Register.dig_H2);
H3 = ReadByte((byte)Register.dig_H3);
H4 = (short)(ReadByte((byte)Register.dig_H4) << 4 | ReadByte((byte)Register.dig_H4 + 1) & 0xf);
H5 = (short)(ReadByte((byte)Register.dig_H5 + 1) << 4 | ReadByte((byte)Register.dig_H5) >> 4);
H6 = (sbyte)ReadByte((byte)Register.dig_H6);
//Timerのセット（１秒毎)
periodicTimer = new Timer(this.TimerCallback, null, 0, 1000);
}
public static void Initiate(int slaveAddress, I2cBusSpeed speedMode)
{
var settings = new I2cConnectionSettings(slaveAddress);
settings.BusSpeed = speedMode;
var controller = I2cController.GetDefaultAsync().GetResults();
device = controller.GetDevice(settings);
}
public async void Initialize()
{
//app = new MainPage();
var settings = new I2cConnectionSettings(ADAPTOR_I2C_ADDR);
settings.BusSpeed = I2cBusSpeed.FastMode;
var controller = await I2cController.GetDefaultAsync();
Adaptor = controller.GetDevice(settings);
/* Reset Adaptor */
try
{
WriteRegister(IOCONTROL, 0x08);
}
catch
{
/* ignore NACK exception after software reset */
}
/* Ping Adaptor */
try
{
WriteRegister(SPR, 0x5A);
if (ReadRegister(SPR) != 0x5A)
{
Debug.WriteLine("MHZ16 Ping Failed");
return;
}
}
catch (Exception ex)
{
Debug.WriteLine("I2C Communication Failed with MHZ16: " + ex.Message);
return;
}
/* Configure Adaptor (FIFO, Baudrate setting etc.) */
try
{
WriteRegister(FCR, 0x07);
WriteRegister(LCR, 0x83);
WriteRegister(DLL, 0x60);
WriteRegister(DLH, 0x00);
WriteRegister(LCR, 0x03);
}
catch (Exception ex)
{
Debug.WriteLine("Failed to Initialize MHZ16 Adaptor: " + ex.Message);
return;
}
/* Now that everything is initialized, create a timer so we read concentration every 2 seconds */
//PeriodicTimer = new Timer(this.TimerCallback, null, 0, 2000);
}
public async void Initialize()
{
var settings = new I2cConnectionSettings(I2C_SENSOR_ADDR);
settings.BusSpeed = I2cBusSpeed.FastMode;
var controller = await I2cController.GetDefaultAsync();
i2CDevice = controller.GetDevice(settings);
}
/// <summary>
/// Initialize
/// </summary>
public async Task InitializeAsync()
{
var settings = new I2cConnectionSettings(MLX90614_ADDR);
settings.BusSpeed = I2cBusSpeed.StandardMode;
var controller = await I2cController.GetDefaultAsync();
sensor = controller.GetDevice(settings);
}
/// <summary>
/// Initialize the sensor
/// </summary>
/// <returns></returns>
public async Task InitializeAsync()
{
var settings = new I2cConnectionSettings(RTC_I2C_ADDR);
settings.BusSpeed = I2cBusSpeed.FastMode;
var controller = await I2cController.GetDefaultAsync();
sensor = controller.GetDevice(settings);
}
public static async Task <SN3218LEDDriver> Open()
{
var result = new SN3218LEDDriver();
var i2cSettings = new I2cConnectionSettings(I2C_ADDRESS);
var controller = await I2cController.GetDefaultAsync();
// i2cSettings.SharingMode = I2cSharingMode.Shared;
result.Device = controller.GetDevice(i2cSettings);
return(result);
}
private async Task initI2c()
{
I2cConnectionSettings settings = new I2cConnectionSettings(I2C_ADDRESS)
{
BusSpeed = I2cBusSpeed.FastMode
};
var controller = await I2cController.GetDefaultAsync();
rtc = controller.GetDevice(settings);
}
public static async Task <ADS1015> Open()
{
var i2cSettings = new I2cConnectionSettings(I2C_ADDRESS);
var controller = await I2cController.GetDefaultAsync();
var device = controller.GetDevice(i2cSettings);
var result = new ADS1015(device);
return(result);
}
static async void i2cdump(string[] input)
{
if (input.Length == 2)
{
int slave = Convert.ToInt32(input[1], 16);
UpBridge.Up upb = new UpBridge.Up();
I2cController controller = await I2cController.GetDefaultAsync();
// Int32.TryParse(input[1],out slave);
I2cConnectionSettings Settings = new I2cConnectionSettings(slave);
Console.WriteLine(" 0 1 2 3 4 5 6 7 8 9 a b c d e f");
byte[] writebuf = new byte[1];
byte[] readbuf = new byte[1];
try
{
for (uint i = 0; i < 256; i += 16)
{
if (i == 0)
{
Console.Write("00: ");
}
else
{
Console.Write(Convert.ToString(i, 16) + ": ");
}
for (uint j = 0; j < 16; j++)
{
writebuf[0] = (byte)(i + j);
controller.GetDevice(Settings).WriteRead(writebuf, readbuf);
if (readbuf[0] < 0x10)
{
Console.Write("0" + Convert.ToString(readbuf[0], 16) + " ");
}
else
{
Console.Write(Convert.ToString(readbuf[0], 16) + " ");
}
}
Console.Write("\n");
}
}
catch (Exception)
{
Console.Write("NOT to read Data" + "\n");
}
}
else
{
Console.WriteLine("command error,plese refer to below example \n" +
"i2cdump {i2c address}\n");
Console.WriteLine(Usage);
}
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
deferral = taskInstance.GetDeferral();
//Ox40 was determined by looking at the datasheet for the device
var controller = await I2cController.GetDefaultAsync();
sensor = controller.GetDevice(new I2cConnectionSettings(0x40));
timer = ThreadPoolTimer.CreatePeriodicTimer(Timer_Tick, TimeSpan.FromMilliseconds(500));
}
public async Task Initialize(int i2cAddress)
{
var settings = new I2cConnectionSettings(i2cAddress);
settings.BusSpeed = I2cBusSpeed.FastMode;
settings.SharingMode = I2cSharingMode.Shared;
var controller = await I2cController.GetDefaultAsync();
_distanceMeasurementSensor = controller.GetDevice(settings);
}
public async Task InitializeAsync()
{
var settings = new I2cConnectionSettings(OLED_ADDR);
settings.BusSpeed = I2cBusSpeed.StandardMode;
var controller = await I2cController.GetDefaultAsync();
sensor = controller.GetDevice(settings);
InitCommand();
FillScreen(0x00, 0x00);
}
public async void InitHardware()
{
try
{
if (LightningProvider.IsLightningEnabled)
{
LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();
}
else
{
return;
}
_ioController = GpioController.GetDefault();
_interruptPin = _ioController.OpenPin(InterruptPin);
_interruptPin.Write(GpioPinValue.Low);
_interruptPin.SetDriveMode(GpioPinDriveMode.Input);
_interruptPin.ValueChanged += Interrupt;
//var aqs = I2cDevice.GetDeviceSelector();
//var collection = await DeviceInformation.FindAllAsync(aqs);
I2cController controller = await I2cController.GetDefaultAsync();
var settings = new I2cConnectionSettings(Constants.Address)
{
BusSpeed = I2cBusSpeed.FastMode,
SharingMode = I2cSharingMode.Exclusive
};
//Mpu6050Device = await I2cDevice.FromIdAsync(collection[0].Id, settings);
Mpu6050Device = controller.GetDevice(settings);
await Task.Delay(3); // wait power up sequence
ReadWrite.WriteByte(Constants.PwrMgmt1, 0x80); // reset the device
await Task.Delay(100);
ReadWrite.WriteByte(Constants.PwrMgmt1, 0x2);
ReadWrite.WriteByte(Constants.UserCtrl, 0x04); //reset fifo
ReadWrite.WriteByte(Constants.PwrMgmt1, 1); // clock source = gyro x
ReadWrite.WriteByte(Constants.GyroConfig, 0); // +/- 250 degrees sec
ReadWrite.WriteByte(Constants.AccelConfig, 0); // +/- 2g
ReadWrite.WriteByte(Constants.Config, 1); // 184 Hz, 2ms delay
ReadWrite.WriteByte(Constants.SmplrtDiv, 19); // set rate 50Hz
ReadWrite.WriteByte(Constants.FifoEn, 0x78); // enable accel and gyro to read into fifo
ReadWrite.WriteByte(Constants.UserCtrl, 0x40); // reset and enable fifo
ReadWrite.WriteByte(Constants.IntEnable, 0x1);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
}
private void Initialize()
{
var connection = new I2cConnectionSettings(_address)
{
BusSpeed = I2cBusSpeed.FastMode,
SharingMode = I2cSharingMode.Shared
};
I2cController controller = I2cController.GetDefaultAsync().AsTask().Result;
_device = controller.GetDevice(connection);
}