private async Task Initialize()
{
try
{
if (Interlocked.CompareExchange(ref _isInitialized, 1, 0) == 1)
{
return;
}
// Get a selector string that will return all I2C controllers on the system
string deviceSelector = I2cDevice.GetDeviceSelector();
// Find the I2C bus controller device with our selector string
var dis = await DeviceInformation.FindAllAsync(deviceSelector);
if (dis.Count == 0)
{
throw new Hdc100XInitializationException("No I2C controllers were found on the system");
}
var settings = new I2cConnectionSettings((int)_busAddress)
{
BusSpeed = I2cBusSpeed.FastMode
};
_sensorDevice = await I2cDevice.FromIdAsync(dis[0].Id, settings);
if (_sensorDevice == null)
{
throw new Hdc100XInitializationException(string.Format(
"Slave address {0} on I2C Controller {1} is currently in use by " +
"another application. Please ensure that no other applications are using I2C.",
settings.SlaveAddress,
dis[0].Id));
}
// Configure sensor:
// - measure with 14bit precision
// - measure both temperature and humidity
_sensorDevice.Write(new byte[] { 0x02, 0x10, 0x00 });
_initalizationCompletion.SetResult(true);
}
catch (Hdc100XInitializationException)
{
_initalizationCompletion.SetResult(false);
throw;
}
catch (Exception exc)
{
_initalizationCompletion.SetResult(false);
throw new Hdc100XInitializationException("Unexpected error during initialization", exc);
}
}
internal async void InitializeSystem()
{
// initialize I2C communications
string deviceSelector = I2cDevice.GetDeviceSelector();
DeviceInformationCollection _i2cDeviceControllers = await DeviceInformation.FindAllAsync(deviceSelector);
if (_i2cDeviceControllers.Count == 0)
{
throw new I2cControllerNotFoundException(); ;
}
I2cConnectionSettings ambientTempI2cSettings = new I2cConnectionSettings(AMBIENT_TEMP_BASE_ADDRESS);
ambientTempI2cSettings.BusSpeed = I2cBusSpeed.StandardMode;
_i2cTempDevice = await I2cDevice.FromIdAsync(_i2cDeviceControllers[0].Id, ambientTempI2cSettings);
if (_i2cTempDevice == null)
{
throw new Exception(string.Format(
"Slave address {0} is currently in use on {1}. " +
"Please ensure that no other applications are using I2C.",
ambientTempI2cSettings.SlaveAddress,
_i2cDeviceControllers[0].Id));
}
HardwareReady = true;
if (SensorReady != null)
SensorReady(this, EventArgs.Empty);
}
public async Task Initialise(byte HardwareDeviceAddress)
{
System.Diagnostics.Debug.WriteLine("Initalise Started");
System.Diagnostics.Debug.WriteLine("Finding Device");
I2cConnectionSettings i2cSettings = new I2cConnectionSettings(HardwareDeviceAddress);
i2cSettings.BusSpeed = I2cBusSpeed.FastMode;
string DeviceSelector = I2cDevice.GetDeviceSelector(I2C_CONTROLLER_NAME);
DeviceInformationCollection i2cDeviceControllers = await DeviceInformation.FindAllAsync(DeviceSelector);
i2cDeviceChannel = await I2cDevice.FromIdAsync(i2cDeviceControllers[0].Id, i2cSettings);
System.Diagnostics.Debug.WriteLine("Device Found");
byte[] writeBuffer;
// Shutdown Register
writeBuffer = new byte[] { 0x00, 0x01 };
i2cDeviceChannel.Write(writeBuffer);
Debug.WriteLine("Shutdown Register set");
// Pin Enable Registers
writeBuffer = new byte[] { 0x13, 0xff };
i2cDeviceChannel.Write(writeBuffer);
writeBuffer = new byte[] { 0x14, 0xff };
i2cDeviceChannel.Write(writeBuffer);
writeBuffer = new byte[] { 0x15, 0xff };
i2cDeviceChannel.Write(writeBuffer);
System.Diagnostics.Debug.WriteLine("Initalise Complete");
}
public async void Init()
{
try
{
string aqs = I2cDevice.GetDeviceSelector(); /* Get a selector string that will return all I2C controllers on the system */
var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the I2C bus controller device with our selector string */
var settings = new I2cConnectionSettings(I2CAddress)
{
BusSpeed = I2cBusSpeed.FastMode
};
_device = await I2cDevice.FromIdAsync(dis[0].Id, settings);
if (_device == null)
{
}
else
{
_isInited = true;
}
}
catch
{
_isInited = false;
throw;
}
}
private async void initI2C()
{
try
{
var i2cSettings = new I2cConnectionSettings(I2C_ARDUINO);
i2cSettings.BusSpeed = I2cBusSpeed.FastMode;
string deviceSelector = I2cDevice.GetDeviceSelector(I2C_CONTROLLER_NAME);
var i2cDeviceControllers = await DeviceInformation.FindAllAsync(deviceSelector);
var i2cdev = await I2cDevice.FromIdAsync(i2cDeviceControllers[0].Id, i2cSettings);
byte[] wbuffer = new byte[] { 1, 2 };
byte[] rbuffer = new byte[8];
//var resutl = i2cdev.WriteReadPartial(wbuffer, rbuffer);
//Debug.WriteLine(resutl.Status);
//i2cdev.WriteRead(wbuffer, rbuffer);
i2cdev.Write(wbuffer);
await Task.Delay(10000);
var resutl = i2cdev.ReadPartial(rbuffer);
Debug.WriteLine(rbuffer[0]);
}
catch (Exception ex)
{
throw;
}
}
/// <summary>
/// Initializes the I2C connection and channels.
/// </summary>
/// <returns>A <see cref="Task"/> instance which can be awaited on for completion.</returns>
public async Task Init()
{
if (SlaveAddress < 0) throw new Exception("Invalid SlaveAddress value configured. Please call the class constructor with a valid I2C bus slave address.");
Debug.WriteLine("Initializing PCA9685 against slave address {0}.", SlaveAddress);
string aqs = I2cDevice.GetDeviceSelector();
var i2cDevices = await DeviceInformation.FindAllAsync(aqs);
if (i2cDevices.Count == 0)
{
Debug.WriteLine("No I2C controllers were found on the system.");
return;
}
var settings = new I2cConnectionSettings(GeneralCallSlaveAddress);
settings.BusSpeed = I2cBusSpeed.FastMode;
GeneralCallDev = await I2cDevice.FromIdAsync(i2cDevices[0].Id, settings);
if (GeneralCallDev == null)
{
var errorMessage = string.Format(
"Slave address {0} on I2C Controller {1} is currently in use by another application.",
settings.SlaveAddress,
i2cDevices[0].Id);
throw new Exception(errorMessage);
}
SoftwareReset();
settings = new I2cConnectionSettings(SlaveAddress);
settings.BusSpeed = I2cBusSpeed.FastMode;
Dev = await I2cDevice.FromIdAsync(i2cDevices[0].Id, settings);
if (Dev == null)
{
var errorMessage = string.Format(
"Slave address {0} on I2C Controller {1} is currently in use by another application.",
settings.SlaveAddress,
i2cDevices[0].Id);
throw new Exception(errorMessage);
}
Debug.WriteLine("PCA9685 I2C channels created.");
SetAllChannelsDutyCycle(0.0f);
// Output drive mode is totem-pole not open drain
WriteReg(MODE2, OUTDRV);
// Turn-off oscillator and acknowledge All-Call transfers
WriteReg(MODE1, ALLCALL);
await Task.Delay(1);
byte mode1 = ReadReg(MODE1);
// Turn on oscillator
mode1 &= unchecked((byte)~SLEEP);
WriteReg(MODE1, mode1);
await Task.Delay(1);
Debug.WriteLine("PCA9685 initialization complete.");
}
public async Task Initialize()
{
Debug.WriteLine("TCS34725::Initialize");
try
{
var settings = new I2cConnectionSettings(TCS34725_Address);
settings.BusSpeed = I2cBusSpeed.FastMode;
string aqs = I2cDevice.GetDeviceSelector(I2CControllerName);
var dis = await DeviceInformation.FindAllAsync(aqs);
colorSensor = await I2cDevice.FromIdAsync(dis[0].Id, settings);
// Now setup the LedControlPin
gpio = GpioController.GetDefault();
LedControlGPIOPin = gpio.OpenPin(LedControlPin);
LedControlGPIOPin.SetDriveMode(GpioPinDriveMode.Output);
}
catch (Exception e)
{
Debug.WriteLine("Exception: " + e.Message + "\n" + e.StackTrace);
throw;
}
}
public static async Task<I2cDevice> GetDevice(int address, string controllerName)
{
var key = $"{address} - {controllerName}";
if (_deviceCache.ContainsKey(key))
{
return _deviceCache[key];
}
using (var l = await _locker.LockAsync())
{
if (_deviceCache.ContainsKey(key))
{
return _deviceCache[key];
}
var settings = new I2cConnectionSettings(address) { BusSpeed = I2cBusSpeed.FastMode };
var aqs = I2cDevice.GetDeviceSelector(controllerName);
var dis = await DeviceInformation.FindAllAsync(aqs);
var i2Cdevice = await I2cDevice.FromIdAsync(dis[0].Id, settings);
if (i2Cdevice == null)
{
return null;
}
_deviceCache.Add(key, i2Cdevice);
return i2Cdevice;
}
}
public async Task< List<byte> > GetAvailableDevicesAddress()
{
// get aqs filter to find i2c device
string aqs = I2cDevice.GetDeviceSelector("I2C1");
// Find the I2C bus controller with our selector string
var dis = await DeviceInformation.FindAllAsync(aqs);
if (dis.Count == 0)
throw new Exception("There is no I2C device"); // bus not found
List<byte> devicesList = new List<byte>();
for (byte i = 0; i < 127; i++)
{
I2cConnectionSettings settings = new I2cConnectionSettings(i);
// Create an I2cDevice with our selected bus controller and I2C settings
var device = await I2cDevice.FromIdAsync(dis[0].Id, settings);
var result = device.WritePartial(new byte[] { 0x00 });
if (result.Status == I2cTransferStatus.SlaveAddressNotAcknowledged) continue;
devicesList.Add(i);
device.Dispose();
}
return devicesList;
}
public async void Run(IBackgroundTaskInstance taskInstance)
{
//
// TODO: Insert code to perform background work
//
// If you start any asynchronous methods here, prevent the task
// from closing prematurely by using BackgroundTaskDeferral as
// described in http://aka.ms/backgroundtaskdeferral
//
var deferral = taskInstance.GetDeferral();
var settings = new I2cConnectionSettings(I2C_ADDRESS);
settings.BusSpeed = I2cBusSpeed.FastMode;
var aqs = I2cDevice.GetDeviceSelector(); /* Get a selector string that will return all I2C controllers on the system */
var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the I2C bus controller devices with our selector string */
_dht11 = await I2cDevice.FromIdAsync(dis[0].Id, settings); /* Create an I2cDevice with our selected bus controller and I2C settings */
await begin();
while (true)
{
var temp = await readTemperature();
var hum = await readHumidity();
Debug.WriteLine($"{temp} C & {hum}% humidity");
await Task.Delay(2000);
}
deferral.Complete();
}
//Method to initialize the BMP280 sensor
public async Task InitializeAsync()
{
Debug.WriteLine("BMP280::InitializeAsync");
try
{
//Instantiate the I2CConnectionSettings using the device address of the BMP280
var settings = new I2cConnectionSettings(Bmp280Address)
{
BusSpeed = I2cBusSpeed.FastMode
};
//Set the I2C bus speed of connection to fast mode
//Use the I2CBus device selector to create an advanced query syntax string
var aqs = I2cDevice.GetDeviceSelector(I2CControllerName);
//Use the Windows.Devices.Enumeration.DeviceInformation class to create a collection using the advanced query syntax string
var dis = await DeviceInformation.FindAllAsync(aqs);
//Instantiate the the BMP280 I2C device using the device id of the I2CBus and the I2CConnectionSettings
_bmp280 = await I2cDevice.FromIdAsync(dis[0].Id, settings);
//Check if device was found
if (_bmp280 == null)
{
Debug.WriteLine("Device not found");
}
}
catch (Exception e)
{
Debug.WriteLine("Exception: " + e.Message + "\n" + e.StackTrace);
throw;
}
}
public async void Run()
{
var deviceSelector = I2cDevice.GetDeviceSelector("I2C1");
var devices = await DeviceInformation.FindAllAsync(deviceSelector);
if (devices.Count == 0)
{
return;
}
var settings = new I2cConnectionSettings(0x54); // 0x54 is the I2C device address for the PiGlow
using (I2cDevice device = await I2cDevice.FromIdAsync(devices[0].Id, settings))
{
InitPyGlow(device);
await Pulsate(
device,
brightness: 64,
numberOfPulses: 3,
speedOfPulses: 100);
await Pinwheel(
device,
brightness: 64,
numberOfSpins: 5,
speedOfSpin: 300);
ClearLeds(device);
}
}
private async Task StartScenarioAsync()
{
string i2cDeviceSelector = I2cDevice.GetDeviceSelector();
IReadOnlyList<DeviceInformation> devices = await DeviceInformation.FindAllAsync(i2cDeviceSelector);
// 0x40 was determined by looking at the datasheet for the HTU21D sensor.
var HTU21D_settings = new I2cConnectionSettings(0x40);
// If this next line crashes with an ArgumentOutOfRangeException,
// then the problem is that no I2C devices were found.
//
// If the next line crashes with Access Denied, then the problem is
// that access to the I2C device (HTU21D) is denied.
//
// The call to FromIdAsync will also crash if the settings are invalid.
//
// FromIdAsync produces null if there is a sharing violation on the device.
// This will result in a NullReferenceException in Timer_Tick below.
htu21dSensor = await I2cDevice.FromIdAsync(devices[0].Id, HTU21D_settings);
// Start the polling timer.
timer = new DispatcherTimer() { Interval = TimeSpan.FromMilliseconds(500) };
timer.Tick += Timer_Tick;
timer.Start();
}
/// <summary>
/// Moves servo to specified angle
/// </summary>
/// <param name="Angle">Angle to be moved</param>
/// <returns></returns>
public static async System.Threading.Tasks.Task<byte[]> MoveServo(byte Angle)
{
byte[] Response = new byte[1];
/* Gateway's I2C SLAVE address */
int SlaveAddress = 64; // 0x40
try
{
// Initialize I2C
var Settings = new I2cConnectionSettings(SlaveAddress);
Settings.BusSpeed = I2cBusSpeed.StandardMode;
if (AQS == null || DIS == null)
{
AQS = I2cDevice.GetDeviceSelector("I2C1");
DIS = await DeviceInformation.FindAllAsync(AQS);
}
using (I2cDevice Device = await I2cDevice.FromIdAsync(DIS[0].Id, Settings))
{
/* Send byte to the gateway to move servo at specified position */
Device.Write(new byte[] { Angle });
}
}
catch (Exception)
{
// SUPPRESS ANY ERROR
}
/* Return dummy or ZERO */
return Response;
}
/// <summary>
/// Instanciate asyncronously a new PCF8591 object.
/// As System.Threading.Tasks.Task are not valid Windows Runtime type supported, this method has been set to private and is publicly exposed through the IAsyncOperation method "Create".
/// </summary>
/// <param name="BusSpeed">The I2C Bus Speed. Default value: StandardMode </param>
/// <param name="SharingMode">The I2C Sharing Mode. Default value is Exclusive. To use with caution </param>
/// <returns></returns>
async static private Task <PCF8591> CreateAsync(I2cBusSpeed BusSpeed, I2cSharingMode SharingMode)
{
PCF8591 newADC = new PCF8591();
/// advanced query syntax used to find devices on the RaspberryPi.
string AQS = Windows.Devices.I2c.I2cDevice.GetDeviceSelector();
var DevicesInfo = await Windows.Devices.Enumeration.DeviceInformation.FindAllAsync(AQS);
if (DevicesInfo.Count == 0)
{
throw new Exception("No Device Information were found with query: " + AQS);
}
// I2C bus settings
var settings = new Windows.Devices.I2c.I2cConnectionSettings(addr_PCF8591);
settings.BusSpeed = BusSpeed;
settings.SharingMode = SharingMode;
// Reteives the device from the I2C bus with the given ID.
newADC.device = await Windows.Devices.I2c.I2cDevice.FromIdAsync(DevicesInfo[0].Id, settings);
if (newADC.device == null)
{
throw new Exception("No I2C Device were found with ID " + DevicesInfo[0].Id);
}
return(newADC);
}
public async Task Initialize()
{
Debug.WriteLine("PCA9685::Initialize");
try
{
var settings = new I2cConnectionSettings(PCA9685_Address);
settings.BusSpeed = I2cBusSpeed.FastMode;
string aqs = I2cDevice.GetDeviceSelector(I2CControllerName);
var dis = await DeviceInformation.FindAllAsync(aqs);
pca9685 = await I2cDevice.FromIdAsync(dis[0].Id, settings);
if (pca9685 == null)
{
Debug.WriteLine("PCA9685 failed to initialize");
}
await Begin();
setPWMFreq(60);
}
catch (Exception e)
{
Debug.WriteLine("Exception: " + e.Message + "\n" + e.StackTrace);
throw;
}
}
public async Task Init()
{
Debug.WriteLine("Initializing PCA9685");
string aqs = I2cDevice.GetDeviceSelector();
var dis = await DeviceInformation.FindAllAsync(aqs);
if (dis.Count == 0)
{
Debug.WriteLine("No I2C controllers were found on the system");
return;
}
var settings = new I2cConnectionSettings(GeneralCallSlaveAddress);
settings.BusSpeed = I2cBusSpeed.FastMode;
GeneralCallDev = await I2cDevice.FromIdAsync(dis[0].Id, settings);
if (GeneralCallDev == null)
{
Debug.WriteLine(
string.Format(
"Slave address {0} on I2C Controller {1} is currently in use by " +
"another application. Please ensure that no other applications are using I2C.",
settings.SlaveAddress,
dis[0].Id));
return;
}
SoftwareReset();
settings = new I2cConnectionSettings(SlaveAddress);
settings.BusSpeed = I2cBusSpeed.FastMode;
Dev = await I2cDevice.FromIdAsync(dis[0].Id, settings);
if (Dev == null)
{
Debug.WriteLine(
string.Format(
"Slave address {0} on I2C Controller {1} is currently in use by " +
"another application. Please ensure that no other applications are using I2C.",
settings.SlaveAddress,
dis[0].Id));
return;
}
Debug.WriteLine("PCA9685 I2C channels created");
SetAllChannelsDutyCycle(0.0f);
// Output drive mode is totem-pole not open drain
WriteReg(MODE2, OUTDRV);
// Turn-offi oscillator and acknowledge All-Call transfers
WriteReg(MODE1, ALLCALL);
await Task.Delay(1);
byte mode1 = ReadReg(MODE1);
// Trun-on oscillator
mode1 &= unchecked((byte)~SLEEP);
WriteReg(MODE1, mode1);
await Task.Delay(1);
Debug.WriteLine("PCA9685 initialization complete");
}
/// <summary>
/// Opens a connection to the specified I2C device address.
/// </summary>
/// <param name="address">The 7-bit right aligned slave address (should not have 0x80
/// bit set!)</param>
/// <returns>A reference to the device</returns>
/// <exception cref="IOException">If I2C1 cannot be opened</exception>
private async Task<I2cDevice> OpenI2CConnection(int address) {
I2cConnectionSettings settings = new I2cConnectionSettings(address);
// Create settings to address device
settings.BusSpeed = I2cBusSpeed.FastMode;
settings.SharingMode = I2cSharingMode.Exclusive;
if (i2cID == null)
throw new IOException("Failed to find I2C controller matching " +
I2C_CONTROLLER);
return await I2cDevice.FromIdAsync(i2cID, settings);
}
private async static Task<I2cDevice> GetDevice(int slaveAddress)
{
string deviceSelector = I2cDevice.GetDeviceSelector();
var deviceControllers = await DeviceInformation.FindAllAsync(deviceSelector);
if (deviceControllers.Count == 0) throw new InvalidOperationException("No i2c controller found.");
var i2cSettings = new I2cConnectionSettings(0x20);
i2cSettings.BusSpeed = I2cBusSpeed.FastMode;
var device = await I2cDevice.FromIdAsync(deviceControllers[0].Id, i2cSettings);
return device;
}
public virtual async Task Init(int n=0)
{
var i2CSettings = new I2cConnectionSettings(0x77)
{
BusSpeed = I2cBusSpeed.FastMode,
SharingMode = I2cSharingMode.Shared
};
var i2c1 = I2cDevice.GetDeviceSelector("I2C1");
var devices = await DeviceInformation.FindAllAsync(i2c1);
sensor = await I2cDevice.FromIdAsync(devices[n].Id, i2CSettings);
}
public I2cDeviceBase(int slaveAddress, I2cBusSpeed busSpeed = I2cBusSpeed.FastMode, I2cSharingMode sharingMode = I2cSharingMode.Shared, string i2cControllerName = RaspberryPiI2cControllerName)
{
// Initialize I2C device
Settings = new I2cConnectionSettings(slaveAddress)
{
BusSpeed = busSpeed,
SharingMode = sharingMode
};
deviceSelector = I2cDevice.GetDeviceSelector(i2cControllerName); /* Find the selector string for the I2C bus controller */
}
public async Task<I2cDevice> InitializeAsync()
{
string advanced_query_syntax = I2cDevice.GetDeviceSelector("I2C1");
DeviceInformationCollection device_information_collection = await DeviceInformation.FindAllAsync(advanced_query_syntax);
string deviceId = device_information_collection[0].Id;
I2cConnectionSettings htdu21d_connection = new I2cConnectionSettings(HTDU21D_I2C_ADDRESS);
htdu21d_connection.BusSpeed = I2cBusSpeed.FastMode;
htdu21d_connection.SharingMode = I2cSharingMode.Shared;
return await I2cDevice.FromIdAsync(deviceId, htdu21d_connection);
}
/* Initialization for I2C accelerometer */
private async void InitI2CAccel()
{
try
{
var settings = new I2cConnectionSettings(ACCEL_I2C_ADDR);
settings.BusSpeed = I2cBusSpeed.FastMode; /* 400KHz bus speed */
string aqs = I2cDevice.GetDeviceSelector(); /* Get a selector string that will return all I2C controllers on the system */
var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the I2C bus controller devices with our selector string */
I2CAccel = await I2cDevice.FromIdAsync(dis[0].Id, settings); /* Create an I2cDevice with our selected bus controller and I2C settings */
if (I2CAccel == null)
{
Text_Status.Text = string.Format(
"Slave address {0} on I2C Controller {1} is currently in use by " +
"another application. Please ensure that no other applications are using I2C.",
settings.SlaveAddress,
dis[0].Id);
return;
}
}
catch (Exception ex)
{
Text_Status.Text = "I2C Initialization failed. Exception: " + ex.Message;
return;
}
/*
* Initialize the accelerometer:
*
* For this device, we create 2-byte write buffers:
* The first byte is the register address we want to write to.
* The second byte is the contents that we want to write to the register.
*/
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 measurement mode */
/* Write the register settings */
try
{
I2CAccel.Write(WriteBuf_DataFormat);
I2CAccel.Write(WriteBuf_PowerControl);
}
/* If the write fails display the error and stop running */
catch (Exception ex)
{
Text_Status.Text = "Failed to communicate with device: " + ex.Message;
return;
}
/* Now that everything is initialized, create a timer so we read data every 100mS */
periodicTimer = new Timer(this.TimerCallback, null, 0, 100);
}
private async void InitializeSystem()
{
// initialize I2C communications
try
{
string deviceSelector = I2cDevice.GetDeviceSelector(I2C_CONTROLLER_NAME);
var i2cDeviceControllers = await DeviceInformation.FindAllAsync(deviceSelector);
//Port expander controlling the Button Panel
var buttonPanelSettings = new I2cConnectionSettings(BUTTON_PANEL_I2C_ADDRESS);
buttonPanelSettings.BusSpeed = I2cBusSpeed.FastMode;
i2cButtonPanel = await I2cDevice.FromIdAsync(i2cDeviceControllers[0].Id, buttonPanelSettings);
//Port expander controlling the LCD Screen
var lcdSettings = new I2cConnectionSettings(LCD_SCREEN_I2C_ADDRESS);
lcdSettings.BusSpeed = I2cBusSpeed.FastMode;
i2cLcdScreen = await I2cDevice.FromIdAsync(i2cDeviceControllers[0].Id, lcdSettings);
Screen = new LcdScreen(i2cLcdScreen);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Exception: {0}", e.Message);
return;
}
// initialize I2C Port Expander registers
try
{
InitializeButtonPanel();
InitializeLcd();
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Exception: {0}", e.Message);
return;
}
try
{
buttonStatusCheckTimer = new DispatcherTimer();
buttonStatusCheckTimer.Interval = TimeSpan.FromMilliseconds(BUTTON_STATUS_CHECK_TIMER_INTERVAL);
buttonStatusCheckTimer.Tick += ButtonStatusCheckTimer_Tick;
buttonStatusCheckTimer.Start();
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Exception: {0}", e.Message);
return;
}
}
public async Task InitializeAsync()
{
string selector = I2cDevice.GetDeviceSelector();
IReadOnlyList<DeviceInformation> i2cDevices = await DeviceInformation.FindAllAsync( selector );
I2cConnectionSettings connectionSettings = new I2cConnectionSettings( ARDUINO_ADDRESS );
this.arduino = await I2cDevice.FromIdAsync( i2cDevices[ 0 ].Id, connectionSettings );
if( this.arduino == null )
{
throw new InvalidOperationException( $"The I2C device on address {ARDUINO_ADDRESS} cannot be found or is currently in use by another application." );
}
}
private async Task InitI2CDevice() {
try {
var settings = new I2cConnectionSettings(I2C_ADDRESS);
settings.BusSpeed = I2cBusSpeed.StandardMode;
string aqs = I2cDevice.GetDeviceSelector(I2C_CONTROLLER_NAME); /* Find the selector string for the I2C bus controller */
var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the I2C bus controller device with our selector string */
I2CDevice = await I2cDevice.FromIdAsync(dis[0].Id, settings); /* Create an I2cDevice with our selected bus controller and I2C settings */
}
catch (Exception ex) {
throw new Exception("I2C Initialization Failed", ex);
}
}
public async void I2CInit()
{
var settings = new I2cConnectionSettings(0x40); // Arduino address
settings.BusSpeed = I2cBusSpeed.StandardMode;
settings.SharingMode = I2cSharingMode.Shared;
settings.SlaveAddress = 0x40;
string aqs = I2cDevice.GetDeviceSelector("I2C1");
var dis = await DeviceInformation.FindAllAsync(aqs);
Device = await I2cDevice.FromIdAsync(dis[0].Id, settings);
// periodicTimer = new Timer(this.TimerCallback, null, 0, 500); // Create a timmer
}
private async Task I2cConnect() {
try {
var settings = new I2cConnectionSettings(I2C_ADDR);
settings.BusSpeed = I2cBusSpeed.FastMode;
string aqs = I2cDevice.GetDeviceSelector(I2C_CONTROLLER_NAME); /* Find the selector string for the I2C bus controller */
var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the I2C bus controller device with our selector string */
i2cDevice = await I2cDevice.FromIdAsync(dis[0].Id, settings); /* Create an I2cDevice with our selected bus controller and I2C settings */
}
catch (Exception e) {
throw new Exception("ht16k33 initisation problem: " + e.Message);
}
}
private const string I2C_CONTROLLER_NAME = "I2C1"; // For Raspberry Pi 2, use I2C1
public async Task<I2cDevice> GetI2cDevice(byte address)
{
string aqs = I2cDevice.GetDeviceSelector(I2C_CONTROLLER_NAME); /* Get a selector string that will return all I2C controllers on the system */
var dis = await DeviceInformation.FindAllAsync(aqs); /* Find the I2C bus controller device with our selector string */
if (dis.Count == 0)
{
throw new InvalidOperationException("No I2C controllers were found on the system");
}
var settings = new I2cConnectionSettings(address);
settings.BusSpeed = I2cBusSpeed.FastMode;
return await I2cDevice.FromIdAsync(dis[0].Id, settings); /* Create an I2cDevice with our selected bus controller and I2C settings */
}
private void InitAccelerometer()
{
var settings = new I2cConnectionSettings(SLAVE_ADDRESS) { BusSpeed = I2cBusSpeed.FastMode };
var aqs = I2cDevice.GetDeviceSelector();
var dis = DeviceInformation.FindAllAsync(aqs);
//Get DeviceInformation:
while (dis.Status != AsyncStatus.Completed) { }
var d = dis.GetResults()[0];
//Get I2cDevice:
var s = I2cDevice.FromIdAsync(d.Id, settings);
while (s.Status != AsyncStatus.Completed) { }
m_pAccelerometer = s.GetResults();
}
private static async Task<MainI2CDevice> CreateDisplayJoystickI2CDevice()
{
string aqsFilter = I2cDevice.GetDeviceSelector();
DeviceInformationCollection collection = await DeviceInformation.FindAllAsync(aqsFilter);
I2cConnectionSettings settings = new I2cConnectionSettings(DeviceAddress)
{
BusSpeed = I2cBusSpeed.StandardMode
};
I2cDevice i2CDevice = await I2cDevice.FromIdAsync(collection[0].Id, settings);
return new MainI2CDevice(i2CDevice);
}
internal I2cDevice(string i2cBus, I2cConnectionSettings settings)
{
// generate a unique ID for the device by joining the I2C bus ID and the slave address, should be pretty unique
// the encoding is (I2C bus number x 1000 + slave address)
// i2cBus is an ASCII string with the bus name in format 'I2Cn'
// need to grab 'n' from the string and convert that to the integer value from the ASCII code (do this by subtracting 48 from the char value)
var controllerId = i2cBus[3] - 48;
var deviceId = (controllerId * deviceUniqueIdMultiplier) + settings.SlaveAddress;
I2cController controller = I2cController.FindController(controllerId);
if (controller == null)
{
// this controller doesn't exist yet, create it...
controller = new I2cController(i2cBus);
}
// check if this device ID already exists
var device = FindDevice(controller, deviceId);
if (device == null)
{
// device doesn't exist, create it...
_connectionSettings = new I2cConnectionSettings(settings.SlaveAddress)
{
BusSpeed = settings.BusSpeed,
SharingMode = settings.SharingMode
};
// save device ID
_deviceId = deviceId;
// call native init to allow HAL/PAL inits related with I2C hardware
NativeInit();
// ... and add this device
controller.DeviceCollection.Add(this);
_syncLock = new object();
}
else
{
// this device already exists, throw an exception
throw new I2cDeviceAlreadyInUseException();
}
}
/// <summary>
/// Initializes new instance of Windows10I2cDevice that will use the specified settings to communicate with the I2C device.
/// </summary>
/// <param name="settings">The connection settings of a device on an I2C bus.</param>
public Windows10I2cDevice(I2cConnectionSettings settings)
{
_settings = settings;
var winSettings = new WinI2c.I2cConnectionSettings(settings.DeviceAddress);
string busFriendlyName = $"I2C{settings.BusId}";
string deviceSelector = WinI2c.I2cDevice.GetDeviceSelector(busFriendlyName);
DeviceInformationCollection deviceInformationCollection = DeviceInformation.FindAllAsync(deviceSelector).WaitForCompletion();
if (deviceInformationCollection.Count == 0)
{
throw new ArgumentException($"No I2C device exists for bus ID {settings.BusId}.", $"{nameof(settings)}.{nameof(settings.BusId)}");
}
_winI2cDevice = WinI2c.I2cDevice.FromIdAsync(deviceInformationCollection[0].Id, winSettings).WaitForCompletion();
if (_winI2cDevice == null)
{
throw new PlatformNotSupportedException($"I2C devices are not supported.");
}
}
/// <summary>
/// Constructs a new I2cDevice object.
/// </summary>
/// <param name="slaveAddress">The bus address of the I²C device. Only 7-bit addressing is supported, so the
/// range of valid values is from 8 to 119.</param>
/// <param name="busSpeed"></param>
internal I2cDevice(string deviceId, I2cConnectionSettings settings)
{
m_deviceId = deviceId.Substring(0, deviceId.Length);
m_settings = new I2cConnectionSettings(settings);
int clockRateKhz = 100;
if (settings.BusSpeed == I2cBusSpeed.FastMode)
{
clockRateKhz = 400;
}
m_configuration = new I2CDevice.Configuration((ushort)settings.SlaveAddress, clockRateKhz);
lock (s_deviceLock)
{
if (s_device == null)
{
s_device = new I2CDevice(m_configuration);
}
++s_deviceRefs;
}
}
/// <summary>
/// Construct a copy of an I2cConnectionSettings object.
/// </summary>
/// <param name="source">Source object to copy from.</param>
internal I2cConnectionSettings(I2cConnectionSettings source)
{
m_slaveAddress = source.m_slaveAddress;
m_busSpeed = source.m_busSpeed;
m_sharingMode = source.m_sharingMode;
}
/// <summary>
/// Retrieves an <see cref="I2cDevice"/> object for the inter-integrated circuit (I2C) bus controller that has the specified plug and play device identifier, using the specified connection settings.
/// </summary>
/// <param name="i2cBus">The plug and play device identifier of the I2C bus controller for which you want to create an <see cref="I2cDevice"/> object.</param>
/// <param name="settings">The connection settings to use for communication with the I2C bus controller that deviceId specifies.</param>
/// <returns>An operation that returns the I2cDevice object.</returns>
/// <remarks>
/// This method is specific to nanoFramework. The equivalent method in the UWP API is: FromIdAsync.
/// </remarks>
/// <exception cref="I2cDeviceAlreadyInUseException">T</exception>
public static I2cDevice FromId(String i2cBus, I2cConnectionSettings settings)
{
return(new I2cDevice(i2cBus, settings));
}
/// <summary>
/// Initializes a copy of a <see cref="I2cConnectionSettings"/> object.
/// </summary>
/// <param name="settings">Object to copy from.</param>
internal I2cConnectionSettings(I2cConnectionSettings settings)
{
_slaveAddress = settings.SlaveAddress;
_busSpeed = settings.BusSpeed;
_sharingMode = settings.SharingMode;
}
/// <summary>
/// Gets the I2C device with the specified settings.
/// </summary>
/// <param name="settings"></param>
/// <returns>The desired connection settings.</returns>
public I2cDevice GetDevice(I2cConnectionSettings settings)
{
//TODO: fix return value. Should return an existing device (if any)
return(new I2cDevice(String.Empty, settings));
}
