Issue using I2C in shared mode. about lightning HOT 8 CLOSED

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Threading.Tasks;
using Microsoft.IoT.Lightning.Providers;
using Windows.Devices;
using Windows.Devices.I2c;

namespace Adafruit
{
  public class I2cController : II2cController
  {
    // I2c Controllers
    private Dictionary<int, Windows.Devices.I2c.I2cController> _controllers;
    // I2c Devices
    private Dictionary<Tuple<int, int>, Windows.Devices.I2c.I2cDevice> _devices;

    public I2cController()
    {
      _controllers = new Dictionary<int, Windows.Devices.I2c.I2cController>();
      _devices = new Dictionary<Tuple<int, int>, Windows.Devices.I2c.I2cDevice>();
    }

    /// <summary>
    /// Initialize the I2C Bus
    /// </summary>
    /// <param name="i2cChannel">Channel of i2C output</param>
    /// <returns>True if port opened successfully</returns>
    private async Task InitializeControllerAsync(int i2cChannel = 1)
    {
      if (_controllers.ContainsKey(i2cChannel)) return;

      if (LightningProvider.IsLightningEnabled)
      {
        if (LowLevelDevicesController.DefaultProvider == null)
          LowLevelDevicesController.DefaultProvider = LightningProvider.GetAggregateProvider();

        var controller = (await Windows.Devices.I2c.I2cController.GetControllersAsync(LightningI2cProvider.GetI2cProvider()))[i2cChannel - 1];

        if (controller == null) throw new IndexOutOfRangeException("i2C channel doesn't exist.");
        _controllers.Add(i2cChannel, controller);
      }
    }

    /// <summary>
    /// Try to register and return a device. Will also pass and return the details of the device if it's already registered
    /// </summary>
    /// <param name="address">Address of the device</param>
    /// <returns>I2c device</returns>
    public async Task<I2cDeviceDetails> GetDeviceAsync(int address, int i2cChannel = 1)
    {
      var deviceAddress = new Tuple<int, int>(i2cChannel, address);

      await InitializeControllerAsync(i2cChannel);
      if (_devices.ContainsKey(deviceAddress)) return new I2cDeviceDetails(i2cChannel, address);

      var settings = new I2cConnectionSettings(address) { SharingMode = I2cSharingMode.Shared };

      // Direct Memory Mapped (Lightning) Driver
      if (Microsoft.IoT.Lightning.Providers.LightningProvider.IsLightningEnabled)
      {
        var newDevice = _controllers[i2cChannel].GetDevice(settings);

        if (newDevice == null) throw new ArgumentOutOfRangeException("Failed to get i2C device.");
        _devices.Add(deviceAddress, newDevice);
      }
      // Inbox Driver - not tested
      else
      {
        var aqs = Windows.Devices.I2c.I2cDevice.GetDeviceSelector(string.Format("I2C{0}", i2cChannel));
        var deviceInformation = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(aqs, null);
        settings.SharingMode = I2cSharingMode.Shared;
        var newDevice = await Windows.Devices.I2c.I2cDevice.FromIdAsync(deviceInformation[0].Id, settings);

        if (newDevice == null) throw new ArgumentOutOfRangeException("Failed to get i2C device.");
        _devices.Add(deviceAddress, newDevice);
      }

      return new I2cDeviceDetails(i2cChannel, address);
    }

    /// <summary>
    /// Reads data from the inter-integrated circuit (I2C) bus on which the device is
    /// connected into the specified buffer.
    /// </summary>
    /// <param name="device">Device to Write then Read from.</param>
    /// <param name="buffer">
    /// The buffer to which you want to read the data from the I2C bus. The length of
    /// the buffer determines how much data to request from the device.
    /// </param>
    public void Read(I2cDeviceDetails device, [Range(0, int.MaxValue)] byte[] buffer)
    {
      if (!_devices.ContainsKey(device.GetDeviceAddress())) throw new NullReferenceException(string.Format("I2C Controller {0} isn't initialized.", device.Channel));

      _devices[device.GetDeviceAddress()].Read(buffer);
    }

    /// <summary>
    /// Reads data from the inter-integrated circuit (I2C) bus on which the device is
    /// connected into the specified buffer, and returns information about the success
    /// of the operation that you can use for error handling.
    /// </summary>
    /// <param name="device">Device to Write then Read from.</param>
    /// <param name="buffer">
    /// The buffer to which you want to read the data from the I2C bus. The length of
    /// the buffer determines how much data to request from the device.
    /// </param>
    /// <returns>
    /// A structure that contains information about the success of the read operation
    /// and the actual number of bytes that the operation read into the buffer.
    /// </returns>
    public I2cTransferResult ReadPartial(I2cDeviceDetails device, [Range(0, int.MaxValue)] byte[] buffer)
    {
      if (!_devices.ContainsKey(device.GetDeviceAddress())) throw new NullReferenceException(string.Format("I2C Controller {0} isn't initialized.", device.Channel));

      return _devices[device.GetDeviceAddress()].ReadPartial(buffer);
    }

    /// <summary>
    /// Writes data to the inter-integrated circuit (I2C) bus on which the device is
    /// connected, based on the bus address specified in the I2cConnectionSettings object
    /// that you used to create the I2cDevice object.
    /// </summary>
    /// <param name="device">Device to Write then Read from.</param>
    /// <param name="buffer">A buffer that contains the data that you want to write to the I2C device. This
    /// data should not include the bus address.
    /// </param>
    public void Write(I2cDeviceDetails device, byte[] buffer)
    {
      if (!_devices.ContainsKey(device.GetDeviceAddress())) throw new NullReferenceException(string.Format("I2C Controller {0} isn't initialized.", device.Channel));

      _devices[device.GetDeviceAddress()].Write(buffer);
    }

    /// <summary>
    /// Writes data to the inter-integrated circuit (I2C) bus on which the device is
    /// connected, and returns information about the success of the operation that you
    /// can use for error handling.
    /// </summary>
    /// <param name="device">Device to Write then Read from.</param>
    /// <param name="buffer">
    /// A buffer that contains the data that you want to write to the I2C device. This
    /// data should not include the bus address.
    /// </param>
    /// <returns>
    /// A structure that contains information about the success of the write operation
    /// and the actual number of bytes that the operation wrote into the buffer.
    /// </returns>
    public I2cTransferResult WritePartial(I2cDeviceDetails device, byte[] buffer)
    {
      if (!_devices.ContainsKey(device.GetDeviceAddress())) throw new NullReferenceException(string.Format("I2C Controller {0} isn't initialized.", device.Channel));

      return _devices[device.GetDeviceAddress()].WritePartial(buffer);
    }

    /// <summary>
    /// Performs an atomic operation to write data to and then read data from the inter-integrated
    /// circuit (I2C) bus on which the device is connected, and sends a restart condition
    /// between the write and read operations.
    /// </summary>
    /// <param name="device">Device to Write then Read from.</param>
    /// <param name="writeBuffer">
    /// A buffer that contains the data that you want to write to the I2C device. This
    /// data should not include the bus address.
    /// </param>
    /// <param name="readBuffer">
    /// The buffer to which you want to read the data from the I2C bus. The length of
    /// the buffer determines how much data to request from the device.
    /// </param>
    public void WriteRead(I2cDeviceDetails device, byte[] writeBuffer, [Range(0, int.MaxValue)] byte[] readBuffer)
    {
      if (!_devices.ContainsKey(device.GetDeviceAddress())) throw new NullReferenceException(string.Format("I2C Controller {0} isn't initialized.", device.Channel));

      _devices[device.GetDeviceAddress()].WriteRead(writeBuffer, readBuffer);
    }

    /// <summary>
    /// Performs an atomic operation to write data to and then read data from the inter-integrated
    ///  circuit (I2C) bus on which the device is connected, and returns information about
    ///  the success of the operation that you can use for error handling.
    /// </summary>
    /// <param name="device">Device to Write then Read from.</param>
    /// <param name="writeBuffer">
    /// A buffer that contains the data that you want to write to the I2C device. This
    /// data should not include the bus address.
    /// </param>
    /// <param name="readBuffer">
    /// The buffer to which you want to read the data from the I2C bus. The length of
    /// the buffer determines how much data to request from the device.
    /// </param>
    /// <returns>
    /// A structure that contains information about whether both the read and write parts
    /// of the operation succeeded and the sum of the actual number of bytes that the
    /// operation wrote and the actual number of bytes that the operation read.
    /// </returns>
    public I2cTransferResult WriteReadPartial(I2cDeviceDetails device, byte[] writeBuffer, [Range(0, int.MaxValue)] byte[] readBuffer)
    {
      if (!_devices.ContainsKey(device.GetDeviceAddress())) throw new NullReferenceException(string.Format("I2C Controller {0} isn't initialized.", device.Channel));

      return _devices[device.GetDeviceAddress()].WriteReadPartial(writeBuffer, readBuffer);
    }
  }
}

decimal _flowOne = 0m;
    public decimal FlowOne { get { return _flowOne; } set { Set(ref _flowOne, value); } }
    decimal _flowTwo = 0m;
    public decimal FlowTwo { get { return _flowTwo; } set { Set(ref _flowTwo, value); } }

    private async Task MonitorSensorsAsync()
    {
      if(Microsoft.IoT.Lightning.Providers.LightningProvider.IsLightningEnabled)
      {
        if(Windows.Devices.LowLevelDevicesController.DefaultProvider == null)
        {
          Windows.Devices.LowLevelDevicesController.DefaultProvider = Microsoft.IoT.Lightning.Providers.LightningProvider.GetAggregateProvider();
          var controller = (await Windows.Devices.I2c.I2cController.GetControllersAsync(Microsoft.IoT.Lightning.Providers.LightningI2cProvider.GetI2cProvider()))[0];
          var deviceOne = controller.GetDevice(new Windows.Devices.I2c.I2cConnectionSettings(40) { SharingMode = Windows.Devices.I2c.I2cSharingMode.Shared });
          var deviceTwo = controller.GetDevice(new Windows.Devices.I2c.I2cConnectionSettings(41) { SharingMode = Windows.Devices.I2c.I2cSharingMode.Shared });

          FlowOne = await ReadRegisterAsync(deviceOne, 0x01);
          FlowTwo = await ReadRegisterAsync(deviceTwo, 0x01);
        }
      }
    }

private void WriteRegister(Windows.Devices.I2c.I2cDevice device, byte register, int value)
    {
      device.WritePartial(
        new byte[] {
        register,
        (byte)((value >> 8) & 0xFF),
        (byte)(value & 0xFF)
      });
    }

    private async Task<int> ReadRegisterAsync(Windows.Devices.I2c.I2cDevice device, byte register)
    {
      device.Write(new byte[] { register });
      await Task.Delay(100); // Max 12-bit conversion time is 586us per sample (default 128 samples = 69ms)

      var readBuffer = new byte[2];
      var result = device.ReadPartial(readBuffer);
      return readBuffer[0] << 8 | readBuffer[1];
    }