public static bool WaitOne(this GpioPin pin, GpioPinEdge edge, TimeSpan timeout)
{
using (var pinEvent = new PinEvent(pin, edge))
{
return(pinEvent.WaitOne(timeout));
}
}
private void MotionSensorPin_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
{
if (currentValue == args.Edge) //TODO: Is it needed? the same edge should not happend twice, it is not state value but state change
{
return;
}
switch (args.Edge)
{
case GpioPinEdge.RisingEdge:
if (MotionDetected == null)
{
return;
}
MotionDetected.Invoke(this, null);
break;
case GpioPinEdge.FallingEdge:
if (MotionUndetected == null)
{
return;
}
MotionUndetected.Invoke(this, null);
break;
}
currentValue = args.Edge;
}
public GpioPin CreateDigitalInputPort(
int pin,
GpioPinEdge interruptMode = GpioPinEdge.FallingEdge,
ResistorMode resistorMode = ResistorMode.Disabled,
double debounceDuration = 0,
double glitchFilterCycleCount = 0)
{
if (IsValidPin(pin))
{
if (resistorMode == ResistorMode.PullDown)
{
Debug.WriteLine("Pull-down resistor mode is not supported.");
throw new Exception("Pull-down resistor mode is not supported.");
}
var enablePullUp = resistorMode == ResistorMode.PullUp ? true : false;
this.ConfigureInputPort(pin, enablePullUp, interruptMode);
var gpio = GpioController.GetDefault();
var port = gpio.OpenPin(pin);
port.SetDriveMode(GpioPinDriveMode.InputPullUp);
//var port = new DigitalInputPort(this, pin, interruptMode);
_inputPorts.Add(pin, port);
return(port);
}
throw new Exception("Pin is out of range");
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="pin">oin the value is for.</param>
/// <param name="interruptOccurred">True when interrupt occurs, false otherwise.</param>
/// <param name="edge">Edge that occurred</param>
/// <param name="currentValue">Current value.</param>
internal PinInterruptValue(int pin, bool interruptOccurred, GpioPinEdge edge, GpioPinValue currentValue)
{
this.Pin = pin;
this.InterruptOccurred = interruptOccurred;
this.Edge = edge;
this.CurrentValue = currentValue;
}
void AddBit(GpioPinEdge edge, Pulse pulse = Pulse.Data0)
{
if (edge != GpioPinEdge.FallingEdge)
{
return;
}
if (!swReadingTimer.IsRunning)
{
swReadingTimer.Start();
timerWatcher = CreateWatcherTimer();
}
if (isAddBitMethodLocked == false)
{
isAddBitMethodLocked = true;
//left-shift bits
valueBuffer <<= 1;
if (pulse == Pulse.Data1)
{
valueBuffer |= 1;
}
bitCount++;
timerWatcher.Change(TIME_IDLEFLAG, TimeSpan.FromMilliseconds(-1));
isAddBitMethodLocked = false;
}
CheckReceivedData();
}
public static GPIOPinEdge ToGPIOPinEdge(this GpioPinEdge pinEdge)
{
return(pinEdge switch
{
GpioPinEdge.FallingEdge => GPIOPinEdge.FallingEdge,
GpioPinEdge.RisingEdge => GPIOPinEdge.RisingEdge,
_ => GPIOPinEdge.None,
});
public GpioPin CreateDigitalInputPort(int pin,
GpioPinEdge interruptMode = GpioPinEdge.FallingEdge,
ResistorMode resistorMode = ResistorMode.Disabled,
double debounceDuration = 0,
double glitchFilterCycleCount = 0)
{
throw new NotImplementedException();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="pin"></param>
/// <param name="mode">The drive mode of the pin. When inputPullUp is used, the pressed state will be true when a falling edge is detected.</param>
public Button(IGpioPin pin, GpioPinDriveMode mode)
{
if (pin == null) throw new ArgumentNullException("pin");
if (mode != GpioPinDriveMode.Input && mode != GpioPinDriveMode.InputPullDown && mode != GpioPinDriveMode.InputPullUp) throw new ArgumentOutOfRangeException("mode", "Drive mode should be an input drive type.");
_pin = pin;
_pressedEdge = mode == GpioPinDriveMode.InputPullUp ? GpioPinEdge.FallingEdge : GpioPinEdge.RisingEdge;
_pin.SetDriveMode(mode);
_pin.ValueChanged += _pin_ValueChanged;
}
/// <summary>
/// Creates a new DipSwitch connected to the specified switchPins, with the InterruptMode and ResisterMode specified by the type parameters.
/// </summary>
/// <param name="device"></param>
/// <param name="switchPins"></param>
/// <param name="interruptMode"></param>
/// <param name="resistorMode"></param>
/// <param name="debounceDuration"></param>
/// <param name="glitchFilterCycleCount"></param>
public DipSwitch(int[] switchPins, GpioPinEdge interruptMode, GpioPinDriveMode resistorMode, int debounceDuration = 20, int glitchFilterCycleCount = 0)
{
Switches = new ISwitch[switchPins.Length];
for (int i = 0; i < switchPins.Length; i++)
{
Switches[i] = new SpstSwitch(switchPins[i], interruptMode, resistorMode, debounceDuration, glitchFilterCycleCount);
int index = i;
Switches[i].Changed += (s, e) => HandleSwitchChanged(index);
}
}
/// <summary>
/// Create a new Parallax PIR object connected to an input pin and IO Device.
/// </summary>
/// <param name="device"></param>
/// <param name="inputPin"></param>
public ParallaxPir(int pin, GpioPinEdge interruptMode, ResistorMode resistorMode, int debounceDuration = 20, int glitchFilterCycleCount = 0)
{
// this (device.CreateDigitalInputPort(pin, interruptMode, resistorMode, debounceDuration, glitchFilterCycleCount))
var gpio = GpioController.GetDefault();
var Dpin = gpio.OpenPin(pin);
Dpin.SetDriveMode(resistorMode == ResistorMode.PullUp ? GpioPinDriveMode.InputPullUp : GpioPinDriveMode.InputPullDown);
Dpin.DebounceTimeout = new TimeSpan(0, 0, 0, debounceDuration);
Dpin.ValueChangedEdge = interruptMode;
Setup(Dpin);
}
/// <summary>
/// Handles internal events and re-dispatches them to the publicly subscribed delegates.
/// </summary>
/// <param name="edge">The state transition for this event.</param>
internal void OnPinChangedInternal(GpioPinEdge edge)
{
GpioPinValueChangedEventHandler callbacks = null;
lock (_syncLock)
{
if (!_disposedValue)
{
callbacks = _callbacks;
}
}
callbacks?.Invoke(this, new GpioPinValueChangedEventArgs(edge));
}
public DigitalInputPort(
Mcp23x08 mcpController,
int pin,
GpioPinEdge interruptMode = GpioPinEdge.FallingEdge)
//: base(pin, (IDigitalChannelInfo)pin.SupportedChannels[0], interruptMode)
{
Pin = pin;
_mcp = mcpController;
_pin = pin;
InterruptMode = interruptMode;
//if (interruptMode != InterruptMode.None)
{
_mcp.InputChanged += PinChanged;
}
}
/// <summary>
/// Constructs a motion sensor device.
/// </summary>
/// <param name="sensorPin">
/// The GPIO number of the pin used for the motion sensor.
/// </param>
/// <param name="sensorType">
/// The motion sensor type: Active low or active high
/// </param>
public PirSensor(int sensorPin, SensorType sensorType)
{
var gpioController = GpioController.GetDefault();
if (gpioController != null)
{
pirSensorEdge = sensorType == SensorType.ActiveLow ? GpioPinEdge.FallingEdge : GpioPinEdge.RisingEdge;
pirSensorPin = gpioController.OpenPin(sensorPin);
pirSensorPin.SetDriveMode(GpioPinDriveMode.Input);
pirSensorPin.ValueChanged += PirSensorPin_ValueChanged;
}
else
{
Debug.WriteLine("Error: GPIO controller not found.");
}
}
/// <summary>
/// Handles internal events and re-dispatches them to the publicly subsribed delegates.
/// </summary>
/// <param name="edge">The state transition for this event.</param>
internal void OnPinChangedInternal(GpioPinEdge edge)
{
GpioPinValueChangedEventHandler callbacks = null;
lock (m_syncLock)
{
if (!m_disposed)
{
callbacks = m_callbacks;
}
}
if (callbacks != null)
{
callbacks(this, new GpioPinValueChangedEventArgs(edge));
}
}
public PirSensorService(int sensorPin, SensorType sensorType, int debounceTimeout = 1000)
{
var gpioController = GpioController.GetDefault();
if (gpioController != null)
{
pirSensorEdge = sensorType == SensorType.ActiveLow ? GpioPinEdge.FallingEdge : GpioPinEdge.RisingEdge;
pirSensorPin = gpioController.OpenPin(sensorPin);
pirSensorPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
pirSensorPin.DebounceTimeout = TimeSpan.FromMilliseconds(debounceTimeout);
pirSensorPin.ValueChanged += PirSensorPin_ValueChanged;
}
else
{
Debug.WriteLine("Error: GPIO controller not found.");
}
}
public void ConfigureInputPort(int pin, bool enablePullUp = false, GpioPinEdge interruptMode = GpioPinEdge.FallingEdge)
{
if (IsValidPin(pin))
{
// set the port direction
this.SetPortDirection(pin, GpioPinDriveMode.Input);
_gppu = _mcpDevice.ReadRegister(RegisterAddresses.PullupResistorConfigurationRegister);
_gppu = BitHelpers.SetBit(_gppu, (byte)pin, enablePullUp);
_mcpDevice.WriteRegister(RegisterAddresses.PullupResistorConfigurationRegister, _gppu);
//if (interruptMode != null)
{
// interrupt on change (whether or not we want to raise an interrupt on the interrupt pin on change)
byte gpinten = _mcpDevice.ReadRegister(RegisterAddresses.InterruptOnChangeRegister);
gpinten = BitHelpers.SetBit(gpinten, (byte)pin, true);
_mcpDevice.WriteRegister(RegisterAddresses.InterruptOnChangeRegister, gpinten);
// Set the default value for the pin for interrupts.
var interruptValue = interruptMode == GpioPinEdge.FallingEdge;
byte defVal = _mcpDevice.ReadRegister(RegisterAddresses.DefaultComparisonValueRegister);
defVal = BitHelpers.SetBit(defVal, (byte)pin, interruptValue);
_mcpDevice.WriteRegister(RegisterAddresses.DefaultComparisonValueRegister, defVal);
// Set the input polarity of the pin. Basically if its normally high, we want to flip the polarity.
var pol = _mcpDevice.ReadRegister(RegisterAddresses.InputPolarityRegister);
pol = BitHelpers.SetBit(pol, (byte)pin, !interruptValue);
_mcpDevice.WriteRegister(RegisterAddresses.InputPolarityRegister, pol);
// interrupt control register; whether or not the change is based
// on default comparison value, or if a change from previous. We
// want to raise on change, so we set it to 0, always.
var interruptControl = interruptMode != GpioPinEdge.RisingEdge; //both
var intCon = _mcpDevice.ReadRegister(RegisterAddresses.InterruptControlRegister);
intCon = BitHelpers.SetBit(intCon, (byte)pin, interruptControl);
_mcpDevice.WriteRegister(RegisterAddresses.InterruptControlRegister, intCon);
}
}
else
{
throw new Exception("Pin is out of range");
}
}
public PinChangedStatus GetChangedStatus(GpioPinEdge edge)
{
PinChangedStatus returnValue = PinChangedStatus.None;
GpioPinValue currentValue = this.GpioPin.Read();
try
{
if (edge == GpioPinEdge.RisingEdge && this.PreviousValue == GpioPinValue.Low && currentValue != this.PreviousValue)
{
returnValue = PinChangedStatus.WentHigh;
}
else if (edge == GpioPinEdge.FallingEdge && this.PreviousValue == GpioPinValue.High && currentValue != this.PreviousValue)
{
returnValue = PinChangedStatus.WentLow;
}
}
finally
{
this.PreviousValue = currentValue;
}
return returnValue;
}
public PinChangedStatus GetChangedStatus(GpioPinEdge edge)
{
PinChangedStatus returnValue = PinChangedStatus.None;
GpioPinValue currentValue = this.GpioPin.Read();
try
{
if (edge == GpioPinEdge.RisingEdge && this.PreviousValue == GpioPinValue.Low && currentValue != this.PreviousValue)
{
returnValue = PinChangedStatus.WentHigh;
}
else if (edge == GpioPinEdge.FallingEdge && this.PreviousValue == GpioPinValue.High && currentValue != this.PreviousValue)
{
returnValue = PinChangedStatus.WentLow;
}
}
finally
{
this.PreviousValue = currentValue;
}
return(returnValue);
}
internal GpioPinValueChangedEventArgs(GpioPinEdge edge)
{
_edge = edge;
}
public PinEvent(GpioPin pin, GpioPinEdge edge)
{
_pin = pin;
_edge = edge;
_event = new AutoResetEvent(false);
}
public async Task NotifyPinEdge(string device, int pinNumber, GpioPinEdge edge)
{
await Clients.All.NotifyPinEdge(device, pinNumber, edge);
}
/// <summary>
/// Creats a new instance of the GpioPinValueChangedEventArgs class
/// </summary>
/// <param name="edge">An enumeration value that indicates the type of change that occurred to the value of the GPIO pin for the GpioPin.ValueChanged event.</param>
public GpioPinValueChangedEventArgs(GpioPinEdge edge)
{
_edge = edge;
}
public void Run(IBackgroundTaskInstance taskInstance)
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
TimeSpan imageUpdateDue;
TimeSpan imageUpdatePeriod;
this.logging.LogEvent("Application starting");
// Log the Application build, OS version information etc.
LoggingFields startupInformation = new LoggingFields();
startupInformation.AddString("Timezone", TimeZoneSettings.CurrentTimeZoneDisplayName);
startupInformation.AddString("OSVersion", Environment.OSVersion.VersionString);
startupInformation.AddString("MachineName", Environment.MachineName);
// This is from the application manifest
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
startupInformation.AddString("ApplicationVersion", string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}"));
try
{
// see if the configuration file is present if not copy minimal sample one from application directory
if (localFolder.TryGetItemAsync(ConfigurationFilename).AsTask().Result == null)
{
StorageFile templateConfigurationfile = Package.Current.InstalledLocation.GetFileAsync(ConfigurationFilename).AsTask().Result;
templateConfigurationfile.CopyAsync(localFolder, ConfigurationFilename).AsTask();
}
IConfiguration configuration = new ConfigurationBuilder().AddJsonFile(Path.Combine(localFolder.Path, ConfigurationFilename), false, true).Build();
this.interruptPinNumber = int.Parse(configuration.GetSection("InterruptPinNumber").Value);
startupInformation.AddInt32("Interrupt pin", this.interruptPinNumber);
this.interruptTriggerOn = (GpioPinEdge)Enum.Parse(typeof(GpioPinEdge), configuration.GetSection("interruptTriggerOn").Value);
startupInformation.AddString("Interrupt Trigger on", this.interruptTriggerOn.ToString());
this.displayPinNumber = int.Parse(configuration.GetSection("DisplayPinNumber").Value);
startupInformation.AddInt32("Display pin", this.interruptPinNumber);
this.azureIoTHubConnectionString = configuration.GetSection("AzureIoTHubConnectionString").Value;
startupInformation.AddString("AzureIoTHubConnectionString", this.azureIoTHubConnectionString);
this.transportType = (TransportType)Enum.Parse(typeof(TransportType), configuration.GetSection("TransportType").Value);
startupInformation.AddString("TransportType", this.transportType.ToString());
}
catch (Exception ex)
{
this.logging.LogMessage("JSON configuration file load or settings retrieval failed " + ex.Message, LoggingLevel.Error);
return;
}
#region AzureIoT Hub connection string creation
try
{
this.azureIoTHubClient = DeviceClient.CreateFromConnectionString(this.azureIoTHubConnectionString, this.transportType);
}
catch (Exception ex)
{
this.logging.LogMessage("AzureIOT Hub DeviceClient.CreateFromConnectionString failed " + ex.Message, LoggingLevel.Error);
return;
}
#endregion
#region Report device and application properties to AzureIoT Hub
try
{
TwinCollection reportedProperties = new TwinCollection();
// This is from the OS
reportedProperties["Timezone"] = TimeZoneSettings.CurrentTimeZoneDisplayName;
reportedProperties["OSVersion"] = Environment.OSVersion.VersionString;
reportedProperties["MachineName"] = Environment.MachineName;
reportedProperties["ApplicationDisplayName"] = package.DisplayName;
reportedProperties["ApplicationName"] = packageId.Name;
reportedProperties["ApplicationVersion"] = string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}");
// Unique identifier from the hardware
SystemIdentificationInfo systemIdentificationInfo = SystemIdentification.GetSystemIdForPublisher();
using (DataReader reader = DataReader.FromBuffer(systemIdentificationInfo.Id))
{
byte[] bytes = new byte[systemIdentificationInfo.Id.Length];
reader.ReadBytes(bytes);
reportedProperties["SystemId"] = BitConverter.ToString(bytes);
}
this.azureIoTHubClient.UpdateReportedPropertiesAsync(reportedProperties).Wait();
}
catch (Exception ex)
{
this.logging.LogMessage("Azure IoT Hub client UpdateReportedPropertiesAsync failed " + ex.Message, LoggingLevel.Error);
return;
}
#endregion
#region Retrieve device twin settings
try
{
LoggingFields configurationInformation = new LoggingFields();
Twin deviceTwin = this.azureIoTHubClient.GetTwinAsync().GetAwaiter().GetResult();
if (!deviceTwin.Properties.Desired.Contains("ImageUpdateDue") || !TimeSpan.TryParse(deviceTwin.Properties.Desired["ImageUpdateDue"].value.ToString(), out imageUpdateDue))
{
this.logging.LogMessage("DeviceTwin.Properties ImageUpdateDue setting missing or invalid format", LoggingLevel.Warning);
return;
}
configurationInformation.AddTimeSpan("ImageUpdateDue", imageUpdateDue);
if (!deviceTwin.Properties.Desired.Contains("ImageUpdatePeriod") || !TimeSpan.TryParse(deviceTwin.Properties.Desired["ImageUpdatePeriod"].value.ToString(), out imageUpdatePeriod))
{
this.logging.LogMessage("DeviceTwin.Properties ImageUpdatePeriod setting missing or invalid format", LoggingLevel.Warning);
return;
}
configurationInformation.AddTimeSpan("ImageUpdatePeriod", imageUpdatePeriod);
if (!deviceTwin.Properties.Desired.Contains("ModelType") || (!Enum.TryParse(deviceTwin.Properties.Desired["ModelType"].value.ToString(), out modelType)))
{
this.logging.LogMessage("DeviceTwin.Properties ModelType setting missing or invalid format", LoggingLevel.Warning);
return;
}
configurationInformation.AddString("ModelType", modelType.ToString());
if (!deviceTwin.Properties.Desired.Contains("ModelPublishedName") || (string.IsNullOrWhiteSpace(deviceTwin.Properties.Desired["ModelPublishedName"].value.ToString())))
{
this.logging.LogMessage("DeviceTwin.Properties ModelPublishedName setting missing or invalid format", LoggingLevel.Warning);
return;
}
modelPublishedName = deviceTwin.Properties.Desired["ModelPublishedName"].value.ToString();
configurationInformation.AddString("ModelPublishedName", modelPublishedName);
if (!deviceTwin.Properties.Desired.Contains("ProjectID") || (!Guid.TryParse(deviceTwin.Properties.Desired["ProjectID"].value.ToString(), out projectId)))
{
this.logging.LogMessage("DeviceTwin.Properties ProjectId setting missing or invalid format", LoggingLevel.Warning);
return;
}
configurationInformation.AddGuid("ProjectID", projectId);
if (!deviceTwin.Properties.Desired.Contains("ProbabilityThreshold") || (!Double.TryParse(deviceTwin.Properties.Desired["ProbabilityThreshold"].value.ToString(), out probabilityThreshold)))
{
this.logging.LogMessage("DeviceTwin.Properties ProbabilityThreshold setting missing or invalid format", LoggingLevel.Warning);
return;
}
configurationInformation.AddDouble("ProbabilityThreshold", probabilityThreshold);
if (!deviceTwin.Properties.Desired.Contains("AzureCognitiveServicesEndpoint") || (string.IsNullOrWhiteSpace(deviceTwin.Properties.Desired["AzureCognitiveServicesEndpoint"].value.ToString())))
{
this.logging.LogMessage("DeviceTwin.Properties AzureCognitiveServicesEndpoint setting missing or invalid format", LoggingLevel.Warning);
return;
}
azureCognitiveServicesEndpoint = deviceTwin.Properties.Desired["AzureCognitiveServicesEndpoint"].value.ToString();
configurationInformation.AddString("AzureCognitiveServicesEndpoint", modelPublishedName);
if (!deviceTwin.Properties.Desired.Contains("AzureCognitiveServicesSubscriptionKey") || (string.IsNullOrWhiteSpace(deviceTwin.Properties.Desired["AzureCognitiveServicesSubscriptionKey"].value.ToString())))
{
this.logging.LogMessage("DeviceTwin.Properties AzureCognitiveServicesSubscriptionKey setting missing or invalid format", LoggingLevel.Warning);
return;
}
azureCognitiveServicesSubscriptionKey = deviceTwin.Properties.Desired["AzureCognitiveServicesSubscriptionKey"].value.ToString();
configurationInformation.AddString("AzureCognitiveServicesSubscriptionKey", azureCognitiveServicesSubscriptionKey);
if (!deviceTwin.Properties.Desired.Contains("DebounceTimeout") || !TimeSpan.TryParse(deviceTwin.Properties.Desired["DebounceTimeout"].value.ToString(), out debounceTimeout))
{
this.logging.LogMessage("DeviceTwin.Properties DebounceTimeout setting missing or invalid format", LoggingLevel.Warning);
return;
}
configurationInformation.AddTimeSpan("DebounceTimeout", debounceTimeout);
this.logging.LogEvent("Configuration settings", configurationInformation);
}
catch (Exception ex)
{
this.logging.LogMessage("Azure IoT Hub client GetTwinAsync failed or property missing/invalid" + ex.Message, LoggingLevel.Error);
return;
}
#endregion
try
{
this.customVisionClient = new CustomVisionPredictionClient(new System.Net.Http.DelegatingHandler[] { })
{
ApiKey = this.azureCognitiveServicesSubscriptionKey,
Endpoint = this.azureCognitiveServicesEndpoint,
};
}
catch (Exception ex)
{
this.logging.LogMessage("Azure Cognitive Services Custom Vision Client configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
this.mediaCapture = new MediaCapture();
this.mediaCapture.InitializeAsync().AsTask().Wait();
}
catch (Exception ex)
{
this.logging.LogMessage("Camera configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
this.displayOffTimer = new Timer(this.TimerCallback, null, Timeout.Infinite, Timeout.Infinite);
#region Wire up interupt handler for image capture request
if (this.interruptPinNumber != 0)
{
try
{
GpioController gpioController = GpioController.GetDefault();
this.interruptGpioPin = gpioController.OpenPin(this.interruptPinNumber);
this.interruptGpioPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
this.interruptGpioPin.ValueChanged += this.InterruptGpioPin_ValueChanged;
this.displayGpioPin = gpioController.OpenPin(this.displayPinNumber);
this.displayGpioPin.SetDriveMode(GpioPinDriveMode.Output);
this.displayGpioPin.Write(GpioPinValue.Low);
}
catch (Exception ex)
{
this.logging.LogMessage("Digital input configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
}
#endregion
#region Wire up command handler for image capture request
try
{
this.azureIoTHubClient.SetMethodHandlerAsync("ImageCapture", this.ImageUpdateHandler, null);
}
catch (Exception ex)
{
this.logging.LogMessage("Azure IoT Hub client ImageCapture SetMethodHandlerAsync failed " + ex.Message, LoggingLevel.Error);
return;
}
#endregion
#region Wire up command handler for device reboot request
try
{
this.azureIoTHubClient.SetMethodHandlerAsync("DeviceReboot", this.DeviceRebootAsync, null);
}
catch (Exception ex)
{
this.logging.LogMessage("Azure IoT Hub client DeviceReboot SetMethodHandlerAsync failed " + ex.Message, LoggingLevel.Error);
return;
}
#endregion
if ((imageUpdateDue != TimeSpan.MinValue) || (imageUpdatePeriod != TimeSpan.MinValue))
{
this.imageUpdatetimer = new Timer(this.ImageUpdateTimerCallback, null, imageUpdateDue, imageUpdatePeriod);
}
this.logging.LogEvent("Application started", startupInformation);
// enable task to continue running in background
this.backgroundTaskDeferral = taskInstance.GetDeferral();
}
public GPinEventArgs(GpioPinEdge edge)
{
this.edge = edge;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="edge">Edge of the event that occurred.</param>
public ValueChangedEventArgs(GpioPinEdge edge)
{
this.Edge = edge;
}
public static int ConvertToLedValue(GpioPinEdge edge)
{
return(edge == GpioPinEdge.RisingEdge ? 0 : 1);
}
/// <summary>
/// Initializes a new instance of the <see cref="ButtonPressedEventArgs"/> class.
/// </summary>
/// <param name="gpioPinEdge">Rising or falling edge</param>
public ButtonPressedEventArgs(GpioPinEdge gpioPinEdge)
{
Edge = gpioPinEdge;
}
internal GpioPinValueChangedEventArgs(GpioPinEdge edge)
{
m_edge = edge;
}
internal GpioPinValueChangedEventArgs(GpioPinEdge edge, DateTime timestamp)
{
this.Edge = edge;
this.Timestamp = timestamp;
}
private void GpioTrigger_ValueChanged(GpioPin sender, GpioPinValueChangedEventArgs args)
{
triggerEdge = args.Edge;
}
public void Run(IBackgroundTaskInstance taskInstance)
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
this.logging.LogEvent("Application starting");
// Log the Application build, OS version information etc.
LoggingFields startupInformation = new LoggingFields();
startupInformation.AddString("Timezone", TimeZoneSettings.CurrentTimeZoneDisplayName);
startupInformation.AddString("OSVersion", Environment.OSVersion.VersionString);
startupInformation.AddString("MachineName", Environment.MachineName);
// This is from the application manifest
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
startupInformation.AddString("ApplicationVersion", string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}"));
try
{
// see if the configuration file is present if not copy minimal sample one from application directory
if (localFolder.TryGetItemAsync(ConfigurationFilename).AsTask().Result == null)
{
StorageFile templateConfigurationfile = Package.Current.InstalledLocation.GetFileAsync(ConfigurationFilename).AsTask().Result;
templateConfigurationfile.CopyAsync(localFolder, ConfigurationFilename).AsTask();
}
IConfiguration configuration = new ConfigurationBuilder().AddJsonFile(Path.Combine(localFolder.Path, ConfigurationFilename), false, true).Build();
this.azureCognitiveServicesEndpoint = configuration.GetSection("AzureCognitiveServicesEndpoint").Value;
startupInformation.AddString("AzureCognitiveServicesEndpoint", this.azureCognitiveServicesEndpoint);
this.azureCognitiveServicesSubscriptionKey = configuration.GetSection("AzureCognitiveServicesSubscriptionKey").Value;
startupInformation.AddString("AzureCognitiveServicesSubscriptionKey", this.azureCognitiveServicesSubscriptionKey);
this.interruptPinNumber = int.Parse(configuration.GetSection("InterruptPinNumber").Value);
startupInformation.AddInt32("Interrupt pin", this.interruptPinNumber);
this.interruptTriggerOn = (GpioPinEdge)Enum.Parse(typeof(GpioPinEdge), configuration.GetSection("interruptTriggerOn").Value);
startupInformation.AddString("Interrupt Trigger on", this.interruptTriggerOn.ToString());
this.displayPinNumber = int.Parse(configuration.GetSection("DisplayPinNumber").Value);
startupInformation.AddInt32("Display pin", this.interruptPinNumber);
this.debounceTimeout = TimeSpan.Parse(configuration.GetSection("debounceTimeout").Value);
startupInformation.AddTimeSpan("Debounce timeout", this.debounceTimeout);
}
catch (Exception ex)
{
this.logging.LogMessage("JSON configuration file load or settings retrieval failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
this.faceClient = new FaceClient(
new Microsoft.Azure.CognitiveServices.Vision.Face.ApiKeyServiceClientCredentials(this.azureCognitiveServicesSubscriptionKey),
new System.Net.Http.DelegatingHandler[] { })
{
Endpoint = this.azureCognitiveServicesEndpoint,
};
}
catch (Exception ex)
{
this.logging.LogMessage("Azure Cognitive Services Face Client configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
this.mediaCapture = new MediaCapture();
this.mediaCapture.InitializeAsync().AsTask().Wait();
}
catch (Exception ex)
{
this.logging.LogMessage("Camera configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
this.displayOffTimer = new Timer(this.TimerCallback, null, Timeout.Infinite, Timeout.Infinite);
try
{
GpioController gpioController = GpioController.GetDefault();
this.interruptGpioPin = gpioController.OpenPin(this.interruptPinNumber);
this.interruptGpioPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
this.interruptGpioPin.ValueChanged += this.InterruptGpioPin_ValueChanged;
this.displayGpioPin = gpioController.OpenPin(this.displayPinNumber);
this.displayGpioPin.SetDriveMode(GpioPinDriveMode.Output);
this.displayGpioPin.Write(GpioPinValue.Low);
}
catch (Exception ex)
{
this.logging.LogMessage("Digital input configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
this.logging.LogEvent("Application started", startupInformation);
// enable task to continue running in background
this.backgroundTaskDeferral = taskInstance.GetDeferral();
}
public void Run(IBackgroundTaskInstance taskInstance)
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
this.logging.LogEvent("Application starting");
// Log the Application build, OS version information etc.
LoggingFields startupInformation = new LoggingFields();
startupInformation.AddString("Timezone", TimeZoneSettings.CurrentTimeZoneDisplayName);
startupInformation.AddString("OSVersion", Environment.OSVersion.VersionString);
startupInformation.AddString("MachineName", Environment.MachineName);
// This is from the application manifest
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
startupInformation.AddString("ApplicationVersion", string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}"));
// ethernet mac address
this.deviceMacAddress = NetworkInterface.GetAllNetworkInterfaces()
.Where(i => i.NetworkInterfaceType.ToString().ToLower().Contains("ethernet"))
.FirstOrDefault()
?.GetPhysicalAddress().ToString();
// remove unsupported charachers from MacAddress
this.deviceMacAddress = this.deviceMacAddress.Replace("-", string.Empty).Replace(" ", string.Empty).Replace(":", string.Empty);
startupInformation.AddString("MacAddress", this.deviceMacAddress);
try
{
// see if the configuration file is present if not copy minimal sample one from application directory
if (localFolder.TryGetItemAsync(ConfigurationFilename).AsTask().Result == null)
{
StorageFile templateConfigurationfile = Package.Current.InstalledLocation.GetFileAsync(ConfigurationFilename).AsTask().Result;
templateConfigurationfile.CopyAsync(localFolder, ConfigurationFilename).AsTask();
this.logging.LogMessage("JSON configuration file missing, templated created", LoggingLevel.Warning);
return;
}
IConfiguration configuration = new ConfigurationBuilder().AddJsonFile(Path.Combine(localFolder.Path, ConfigurationFilename), false, true).Build();
this.azureStorageConnectionString = configuration.GetSection("AzureStorageConnectionString").Value;
startupInformation.AddString("AzureStorageConnectionString", this.azureStorageConnectionString);
this.azureStorageContainerNameLatestFormat = configuration.GetSection("AzureContainerNameFormatLatest").Value;
startupInformation.AddString("ContainerNameLatestFormat", this.azureStorageContainerNameLatestFormat);
this.azureStorageimageFilenameLatestFormat = configuration.GetSection("AzureImageFilenameFormatLatest").Value;
startupInformation.AddString("ImageFilenameLatestFormat", this.azureStorageimageFilenameLatestFormat);
this.azureStorageContainerNameHistoryFormat = configuration.GetSection("AzureContainerNameFormatHistory").Value;
startupInformation.AddString("ContainerNameHistoryFormat", this.azureStorageContainerNameHistoryFormat);
this.azureStorageImageFilenameHistoryFormat = configuration.GetSection("AzureImageFilenameFormatHistory").Value;
startupInformation.AddString("ImageFilenameHistoryFormat", this.azureStorageImageFilenameHistoryFormat);
this.interruptPinNumber = int.Parse(configuration.GetSection("InterruptPinNumber").Value);
startupInformation.AddInt32("Interrupt pin", this.interruptPinNumber);
this.interruptTriggerOn = (GpioPinEdge)Enum.Parse(typeof(GpioPinEdge), configuration.GetSection("interruptTriggerOn").Value);
startupInformation.AddString("Interrupt Trigger on", this.interruptTriggerOn.ToString());
this.debounceTimeout = TimeSpan.Parse(configuration.GetSection("debounceTimeout").Value);
startupInformation.AddTimeSpan("Debounce timeout", this.debounceTimeout);
}
catch (Exception ex)
{
this.logging.LogMessage("JSON configuration file load or settings retrieval failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
this.mediaCapture = new MediaCapture();
this.mediaCapture.InitializeAsync().AsTask().Wait();
}
catch (Exception ex)
{
this.logging.LogMessage("Camera configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
GpioController gpioController = GpioController.GetDefault();
this.interruptGpioPin = gpioController.OpenPin(this.interruptPinNumber);
this.interruptGpioPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
this.interruptGpioPin.ValueChanged += this.InterruptGpioPin_ValueChanged;
}
catch (Exception ex)
{
this.logging.LogMessage("Digital input configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
this.logging.LogEvent("Application started", startupInformation);
// enable task to continue running in background
this.backgroundTaskDeferral = taskInstance.GetDeferral();
}
/// <summary>
/// Handles internal events and re-dispatches them to the publicly subsribed delegates.
/// </summary>
/// <param name="edge">The state transition for this event.</param>
internal void OnPinChangedInternal(GpioPinEdge edge)
{
GpioPinValueChangedEventHandler callbacks = null;
lock (m_syncLock)
{
if (!m_disposed)
{
callbacks = m_callbacks;
}
}
if (callbacks != null)
{
callbacks(this, new GpioPinValueChangedEventArgs(edge));
}
}
