/// <summary>
/// Refreshes the connections from the available device sources
/// </summary>
/// <returns>Collection of connection objects available to the app</returns>
public async Task <Connections> RefreshConnections()
{
Connections connections = new Connections();
connections.Clear();
await BluetoothSerial.listAvailableDevicesAsync().AsTask().ContinueWith(
listTask =>
{
listTask.Result.ForEach(
d => connections.Add(new Connection(d.Name, d, ConnectionType.BluetoothSerial)));
});
await UsbSerial.listAvailableDevicesAsync().AsTask().ContinueWith(
listTask =>
{
listTask.Result.ForEach(
d => connections.Add(new Connection(d.Name, d, ConnectionType.UsbSerial)));
});
string previousConnection = App.CurrentAppSettings.PreviousConnectionName;
if (this.CurrentConnection == null && !string.IsNullOrEmpty(previousConnection) &&
connections.Any(c => c.DisplayName == App.CurrentAppSettings.PreviousConnectionName))
{
await this.Connect(
connections.FirstOrDefault(
c => c.DisplayName == App.CurrentAppSettings.PreviousConnectionName));
}
return(connections);
}
//protected override void OnNavigatedTo(NavigationEventArgs e) {
// base.OnNavigatedTo(e);
// FindConnection();
//}
private void FindConnection()
{
cancelTokenSource = new CancellationTokenSource();
cancelTokenSource.Token.Register(() => OnConnectionCancelled());
Task <DeviceInformationCollection> task = UsbSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>(cancelTokenSource.Token);
if (task != null)
{
//store the returned DeviceInformation items when the task completes
task.ContinueWith(listTask => {
//store the result and populate the device list on the UI thread
var result = listTask.Result;
if (result != null && result.Count > 0)
{
DeviceInformation device = result[0];
App.Connection = new UsbSerial(device);
MakeConnection();
}
});
}
}
public void Run(IBackgroundTaskInstance taskInstance)
{
System.Diagnostics.Debug.WriteLine("hola");
playing = false;
DeviceInformation device = null;
var result = UsbSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>().Result;
if (result == null || result.Count == 0)
{
throw new InvalidOperationException("No USB FOUND");
}
else
{
// Assume first
device = result.FirstOrDefault();
}
Connection = new UsbSerial(device);
Firmata = new UwpFirmata();
Firmata.begin(Connection);
Arduino = new RemoteDevice(Firmata);
Connection.ConnectionEstablished += OnConnectionEstablished;
Connection.begin(BAUD_RATE, SerialConfig.SERIAL_8N1);
}
private async void rad_Checked(object sender, RoutedEventArgs e)
{
RadioButton rad = (RadioButton)sender;
lstDevices.ItemsSource = null;
if (rad == radBluetooth)
{
var bleutoothDevices = await BluetoothSerial.listAvailableDevicesAsync();
lstDevices.ItemsSource = bleutoothDevices;
}
else if (rad == radUSB)
{
var usbDevices = await UsbSerial.listAvailableDevicesAsync();
List <DeviceInformation> _usbDevices = new List <DeviceInformation>();
foreach (var itm in usbDevices)
{
if (itm.Name.Contains("COM"))
{
_usbDevices.Add(itm);
}
}
lstDevices.ItemsSource = _usbDevices;
}
}
private async void grid1_Loaded(object sender, RoutedEventArgs e)
{
var devices = await UsbSerial.listAvailableDevicesAsync();
int idx = -1;
for (int i = 0; i < devices.Count; i++)
{
if (devices[i].Name.StartsWith("Arduino"))
{
idx = i;
}
}
if (idx != -1)
{
usbSerial = new UsbSerial(devices[idx]);
firmata = new UwpFirmata();
arduino = new RemoteDevice(firmata);
firmata.begin(usbSerial);
//arduino.DeviceReady += OnDeviceReady;
//usbSerial.ConnectionEstablished += OnDeviceReady;
firmata.FirmataConnectionReady += OnDeviceReady;
//arduino.SysexMessageReceived += DataRecieved;
firmata.SysexMessageReceived += Firmata_SysexMessageReceived;
firmata.PinCapabilityResponseReceived += Firmata_PinCapabilityResponseReceived;
firmata.DigitalPortValueUpdated += Firmata_DigitalPortValueUpdated;
usbSerial.begin(57600, SerialConfig.SERIAL_8N1);
}
}
public async Task RenewDeviceList(string interfaceType)
{
connections.Clear();
Task <DeviceInformationCollection> task = null;
switch (interfaceType)
{
case "Bluetooth":
task = BluetoothSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>();
break;
case "USB":
task = UsbSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>();
break;
case "DfRobot":
task = DfRobotBleSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>();
break;
}
if (task != null)
{
await task.ContinueWith(listTask =>
{
var result = listTask.Result;
foreach (DeviceInformation device in result)
{
connections.Add(device.Name, device);
}
});
}
}
public static async Task <RemoteDevice> ConnectDevice()
{
await Task.Delay(1000);
if (connection == null)
{
var usbDevices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation info = null;
for (int i = 0; i < usbDevices.Count; i++)
{
var props = usbDevices[i].Properties.Values.ToList();
for (int y = 0; y < props.Count(); y++)
{
if (props[y] == null)
{
continue;
}
if (props[y].ToString().Contains("USB-SERIAL"))
{
info = usbDevices[i];
break;
}
}
if (info != null)
{
break;
}
}
if (info == null)
{
return(null);
}
connection = new UsbSerial(info);
connection.begin(57600, SerialConfig.SERIAL_8N1);
}
if (arduino == null)
{
arduino = new RemoteDevice(connection);
}
return(arduino);
}
private async void Init(ManualResetEvent Done)
{
try
{
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
UsbState State;
foreach (DeviceInformation DeviceInfo in Devices)
{
if (!DeviceInfo.IsEnabled)
{
continue;
}
lock (serialPorts)
{
State = new UsbState()
{
Name = DeviceInfo.Name,
DeviceInformation = DeviceInfo,
SerialPort = new UsbSerial(DeviceInfo)
};
State.SerialPort.ConnectionEstablished += State.SerialPort_ConnectionEstablished;
State.Device = new RemoteDevice(State.SerialPort);
State.Device.DeviceReady += State.Device_DeviceReady;
State.Device.AnalogPinUpdated += State.Device_AnalogPinUpdated;
State.Device.DigitalPinUpdated += State.Device_DigitalPinUpdated;
State.Device.DeviceConnectionFailed += State.Device_DeviceConnectionFailed;
State.Device.DeviceConnectionLost += State.Device_DeviceConnectionLost;
serialPorts[DeviceInfo.Name] = State;
}
State.SerialPort.begin(57600, SerialConfig.SERIAL_8N1);
}
}
catch (Exception ex)
{
Log.Critical(ex);
}
finally
{
Done.Set();
}
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
var devices = await UsbSerial.listAvailableDevicesAsync();
if (!devices.Any())
{
var dialog = new MessageDialog("There is no device connected");
await dialog.ShowAsync();
return;
}
connection = new UsbSerial(devices.First());
arduino = new RemoteDevice(connection);
arduino.DeviceReady += Setup;
connection.begin(57600, SerialConfig.SERIAL_8N1);
}
public MainPage()
{
this.InitializeComponent();
Dictionary <string, UsbSerial> devices = new Dictionary <string, UsbSerial>();
//invoke the listAvailableDevicesAsync method of the correct Serial class. Since it is Async, we will wrap it in a Task and add a llambda to execute when finished
Task <DeviceInformationCollection> task = null;
//create a cancellation token which can be used to cancel a task
CancellationTokenSource cancelTokenSource = new CancellationTokenSource();
task = UsbSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>(cancelTokenSource.Token);
if (task != null)
{
//store the returned DeviceInformation items when the task completes
task.ContinueWith(listTask =>
{
//store the result and populate the device list on the UI thread
var action = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() =>
{
Connections connections = new Connections();
var result = listTask.Result;
if (result == null || result.Count == 0)
{
Debug.WriteLine("[Info] Keine Geräte Gefunden!");
}
else
{
foreach (DeviceInformation device in result)
{
connections.Add(new Connection(device.Name, device));
App.arduino = new Arduino(device);
devices.Add(device.Name, new UsbSerial(device));
}
}
}));
});
}
}
public async Task <ObservableCollection <string> > GetDeviceList(string interfaceType, CancellationToken token)
{
ObservableCollection <string> output = new ObservableCollection <string>();
connections.Clear();
Task <DeviceInformationCollection> task = null;
switch (interfaceType)
{
case "Bluetooth":
task = BluetoothSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>(token);
break;
case "USB":
task = UsbSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>(token);
break;
case "DfRobot":
task = DfRobotBleSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>(token);
break;
}
if (task != null)
{
await task.ContinueWith(listTask =>
{
var result = listTask.Result;
foreach (DeviceInformation device in result)
{
output.Add(device.Name);
connections.Add(device.Name, device);
}
});
}
return(output);
}
public void Run(IBackgroundTaskInstance taskInstance)
{
System.Diagnostics.Debug.WriteLine("hi");
//
// TODO: Insert code to start one or more asynchronous methods
//
playing = false;
DeviceInformation device = null;
var result = UsbSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>().Result;
if (result == null || result.Count == 0)
{
throw new InvalidOperationException("No USB FOUND");
}
else
{
// Assume first
// TODO: Might not be first.
device = result.FirstOrDefault();
}
WriteLine("device name: " + device.Name);
Connection = new UsbSerial(device);
Firmata = new UwpFirmata();
Firmata.begin(Connection);
Arduino = new RemoteDevice(Firmata);
Connection.ConnectionEstablished += OnConnectionEstablished;
Connection.begin(BAUD_RATE, SerialConfig.SERIAL_8N1);
// Begin Recording from mic.
this.StartRecording();
}
public ConnectionPage()
{
playing = false;
this.InitializeComponent();
ConnectionMethodComboBox.SelectionChanged += ConnectionComboBox_SelectionChanged;
Task <DeviceInformationCollection> task = null;
DeviceInformation device = null;
task = UsbSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>();
//task.Wait();
var result = task.Result;
if (result == null || result.Count == 0)
{
throw new InvalidOperationException("No USB FOUND");
}
else
{
// Assume first
device = result.FirstOrDefault();
}
Connection = new UsbSerial(device);
Firmata = new UwpFirmata();
Firmata.begin(Connection);
Arduino = new RemoteDevice(Firmata);
Connection.ConnectionEstablished += OnConnectionEstablished;
Connection.begin(115200, SerialConfig.SERIAL_8N1);
//for (int i = 0; i < 500; i++)
// System.Diagnostics.Debug.WriteLine(i);
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(typeof(FilesProvider).GetTypeInfo().Assembly, typeof(App).GetTypeInfo().Assembly);
Database.Register(new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000));
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
foreach (DeviceInformation DeviceInfo in Devices)
{
if (DeviceInfo.IsEnabled && DeviceInfo.Name.StartsWith("Arduino"))
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += () =>
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(0, PinMode.INPUT); // PIR sensor (motion detection).
MainPage.Instance.DigitalPinUpdated(0, this.arduino.digitalRead(0));
this.arduino.pinMode(1, PinMode.OUTPUT); // Relay.
this.arduino.digitalWrite(1, 0); // Relay set to 0
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
MainPage.Instance.AnalogPinUpdated("A0", this.arduino.analogRead("A0"));
this.sampleTimer = new Timer(this.SampleValues, null, 1000 - DateTime.Now.Millisecond, 1000);
};
this.arduino.AnalogPinUpdated += (pin, value) =>
{
MainPage.Instance.AnalogPinUpdated(pin, value);
};
this.arduino.DigitalPinUpdated += (pin, value) =>
{
MainPage.Instance.DigitalPinUpdated(pin, value);
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
break;
}
}
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(ObjectSerializer).GetTypeInfo().Assembly, // Waher.Persistence.Serialization was broken out of Waher.Persistence.FilesLW after the publishing of the MIoT book.
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
db = new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000);
Database.Register(db);
await db.RepairIfInproperShutdown(null);
await db.Start();
#if GPIO
gpio = GpioController.GetDefault();
if (gpio != null)
{
if (gpio.TryOpenPin(gpioOutputPin, GpioSharingMode.Exclusive, out this.gpioPin, out GpioOpenStatus Status) &&
Status == GpioOpenStatus.PinOpened)
{
if (this.gpioPin.IsDriveModeSupported(GpioPinDriveMode.Output))
{
this.gpioPin.SetDriveMode(GpioPinDriveMode.Output);
bool LastOn = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.gpioPin.Write(LastOn ? GpioPinValue.High : GpioPinValue.Low);
await MainPage.Instance.OutputSet(LastOn);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", LastOn));
}
else
{
Log.Error("Output mode not supported for GPIO pin " + gpioOutputPin.ToString());
}
}
else
{
Log.Error("Unable to get access to GPIO pin " + gpioOutputPin.ToString());
}
}
#else
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo is null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += async() =>
{
try
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
bool LastOn = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.arduino.digitalWrite(9, LastOn ? PinState.HIGH : PinState.LOW);
await MainPage.Instance.OutputSet(LastOn);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", LastOn));
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
#endif
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(IContentEncoder).GetTypeInfo().Assembly,
typeof(ICoapContentFormat).GetTypeInfo().Assembly,
typeof(IDtlsCredentials).GetTypeInfo().Assembly,
typeof(Lwm2mClient).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
Database.Register(new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000));
#if GPIO
gpio = GpioController.GetDefault();
if (gpio != null)
{
if (gpio.TryOpenPin(gpioOutputPin, GpioSharingMode.Exclusive, out this.gpioPin, out GpioOpenStatus Status) &&
Status == GpioOpenStatus.PinOpened)
{
if (this.gpioPin.IsDriveModeSupported(GpioPinDriveMode.Output))
{
this.gpioPin.SetDriveMode(GpioPinDriveMode.Output);
this.output = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.gpioPin.Write(this.output.Value ? GpioPinValue.High : GpioPinValue.Low);
this.digitalOutput0?.Set(this.output.Value);
this.actuation0?.Set(this.output.Value);
await MainPage.Instance.OutputSet(this.output.Value);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", this.output.Value));
}
else
{
Log.Error("Output mode not supported for GPIO pin " + gpioOutputPin.ToString());
}
}
else
{
Log.Error("Unable to get access to GPIO pin " + gpioOutputPin.ToString());
}
}
#else
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
foreach (DeviceInformation DeviceInfo in Devices)
{
if (DeviceInfo.IsEnabled && DeviceInfo.Name.StartsWith("Arduino"))
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += async() =>
{
try
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.output = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.arduino.digitalWrite(9, this.output.Value ? PinState.HIGH : PinState.LOW);
this.digitalOutput0?.Set(this.output.Value);
this.actuation0?.Set(this.output.Value);
await MainPage.Instance.OutputSet(this.output.Value);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", this.output.Value));
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
break;
}
}
#endif
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
/************************************************************************************
* To create an unencrypted CoAP Endpoint on the default CoAP port:
*
* this.coapEndpoint = new CoapEndpoint();
*
* To create an unencrypted CoAP Endpoint on the default CoAP port,
* with a sniffer that outputs communication to the window:
*
* this.coapEndpoint = new CoapEndpoint(new LogSniffer());
*
* To create a DTLS encrypted CoAP endpoint, on the default CoAPS port, using
* the users defined in the IUserSource users:
*
* this.coapEndpoint = new CoapEndpoint(CoapEndpoint.DefaultCoapsPort, this.users);
*
* To create a CoAP endpoint, that listens to both the default CoAP port, for
* unencrypted communication, and the default CoAPS port, for encrypted,
* authenticated and authorized communication, using
* the users defined in the IUserSource users. Only users having the given
* privilege (if not empty) will be authorized to access resources on the endpoint:
*
* this.coapEndpoint = new CoapEndpoint(new int[] { CoapEndpoint.DefaultCoapPort },
* new int[] { CoapEndpoint.DefaultCoapsPort }, this.users, "PRIVILEGE", false, false);
*
************************************************************************************/
this.coapEndpoint = new CoapEndpoint(new int[] { CoapEndpoint.DefaultCoapPort },
new int[] { CoapEndpoint.DefaultCoapsPort }, this.users, string.Empty, false, false);
this.outputResource = this.coapEndpoint.Register("/Output", (req, resp) =>
{
string s;
if (this.output.HasValue)
{
s = this.output.Value ? "true" : "false";
}
else
{
s = "-";
}
resp.Respond(CoapCode.Content, s, 64);
}, async(req, resp) =>
{
try
{
string s = req.Decode() as string;
if (s == null && req.Payload != null)
{
s = Encoding.UTF8.GetString(req.Payload);
}
if (s == null || !CommonTypes.TryParse(s, out bool Output))
{
resp.RST(CoapCode.BadRequest);
}
else
{
resp.Respond(CoapCode.Changed);
await this.SetOutput(Output, req.From.ToString());
}
}
catch (Exception ex)
{
Log.Critical(ex);
}
}, Notifications.Acknowledged, "Digital Output.", null, null,
new int[] { PlainText.ContentFormatCode });
this.outputResource?.TriggerAll(new TimeSpan(0, 1, 0));
this.lwm2mClient = new Lwm2mClient("MIoT:Actuator:" + this.deviceId, this.coapEndpoint,
new Lwm2mSecurityObject(),
new Lwm2mServerObject(),
new Lwm2mAccessControlObject(),
new Lwm2mDeviceObject("Waher Data AB", "ActuatorLwm2m", this.deviceId, "1.0", "Actuator", "1.0", "1.0"),
new DigitalOutput(this.digitalOutput0 = new DigitalOutputInstance(0, this.output.HasValue && this.output.Value, "Relay")),
new Actuation(this.actuation0 = new ActuationInstance(0, this.output.HasValue && this.output.Value, "Relay")));
this.digitalOutput0.OnRemoteUpdate += async(Sender, e) =>
{
try
{
await this.SetOutput(((DigitalOutputInstance)Sender).Value, e.Request.From.ToString());
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
this.actuation0.OnRemoteUpdate += async(Sender, e) =>
{
try
{
await this.SetOutput(((ActuationInstance)Sender).Value, e.Request.From.ToString());
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
await this.lwm2mClient.LoadBootstrapInfo();
this.lwm2mClient.OnStateChanged += (sender, e) =>
{
Log.Informational("LWM2M state changed to " + this.lwm2mClient.State.ToString() + ".");
};
this.lwm2mClient.OnBootstrapCompleted += (sender, e) =>
{
Log.Informational("Bootstrap procedure completed.");
};
this.lwm2mClient.OnBootstrapFailed += (sender, e) =>
{
Log.Error("Bootstrap procedure failed.");
this.coapEndpoint.ScheduleEvent(async(P) =>
{
try
{
await this.RequestBootstrap();
}
catch (Exception ex)
{
Log.Critical(ex);
}
}, DateTime.Now.AddMinutes(15), null);
};
this.lwm2mClient.OnRegistrationSuccessful += (sender, e) =>
{
Log.Informational("Server registration completed.");
};
this.lwm2mClient.OnRegistrationFailed += (sender, e) =>
{
Log.Error("Server registration failed.");
};
this.lwm2mClient.OnDeregistrationSuccessful += (sender, e) =>
{
Log.Informational("Server deregistration completed.");
};
this.lwm2mClient.OnDeregistrationFailed += (sender, e) =>
{
Log.Error("Server deregistration failed.");
};
this.lwm2mClient.OnRebootRequest += async(sender, e) =>
{
Log.Warning("Reboot is requested.");
try
{
await this.RequestBootstrap();
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
await this.RequestBootstrap();
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
Database.Register(new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000));
#if GPIO
gpio = GpioController.GetDefault();
if (gpio != null)
{
if (gpio.TryOpenPin(gpioOutputPin, GpioSharingMode.Exclusive, out this.gpioPin, out GpioOpenStatus Status) &&
Status == GpioOpenStatus.PinOpened)
{
if (this.gpioPin.IsDriveModeSupported(GpioPinDriveMode.Output))
{
this.gpioPin.SetDriveMode(GpioPinDriveMode.Output);
bool LastOn = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.gpioPin.Write(LastOn ? GpioPinValue.High : GpioPinValue.Low);
await MainPage.Instance.OutputSet(LastOn);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", LastOn));
}
else
{
Log.Error("Output mode not supported for GPIO pin " + gpioOutputPin.ToString());
}
}
else
{
Log.Error("Unable to get access to GPIO pin " + gpioOutputPin.ToString());
}
}
#else
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo == null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += async() =>
{
try
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
bool LastOn = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.arduino.digitalWrite(9, LastOn ? PinState.HIGH : PinState.LOW);
await MainPage.Instance.OutputSet(LastOn);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", LastOn));
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
#endif
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
this.mqttClient = new MqttClient("iot.eclipse.org", 8883, true, this.deviceId, string.Empty);
//this.mqttClient = new MqttClient("iot.eclipse.org", 8883, true, this.deviceId, string.Empty, new LogSniffer());
this.mqttClient.OnStateChanged += (sender, state) =>
{
Log.Informational("MQTT client state changed: " + state.ToString());
if (state == MqttState.Connected)
{
this.mqttClient.SUBSCRIBE("Waher/MIOT/" + this.deviceId + "/Set/+", MqttQualityOfService.AtLeastOnce);
}
};
this.mqttClient.OnContentReceived += async(sender, e) =>
{
try
{
if (e.Topic.EndsWith("/On"))
{
string s = Encoding.UTF8.GetString(e.Data);
s = s.Substring(0, 1).ToUpper() + s.Substring(1).ToLower();
if (bool.TryParse(s, out bool On))
{
await this.SetOutput(On, "MQTT");
}
}
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
DateTime Now = DateTime.Now;
this.reconnectionTimer = new Timer(this.CheckConnection, null, 120000 - Now.Millisecond - Now.Second * 1000, 60000);
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
foreach (DeviceInformation DeviceInfo in Devices)
{
if (DeviceInfo.IsEnabled && DeviceInfo.Name.StartsWith("Arduino"))
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += () =>
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
MainPage.Instance.DigitalPinUpdated(8, this.arduino.digitalRead(8));
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.arduino.digitalWrite(9, 0); // Relay set to 0
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
MainPage.Instance.AnalogPinUpdated("A0", this.arduino.analogRead("A0"));
};
this.arduino.AnalogPinUpdated += (pin, value) =>
{
MainPage.Instance.AnalogPinUpdated(pin, value);
};
this.arduino.DigitalPinUpdated += (pin, value) =>
{
MainPage.Instance.DigitalPinUpdated(pin, value);
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
break;
}
}
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
Database.Register(new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000));
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo == null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += () =>
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
PinState Pin8 = this.arduino.digitalRead(8);
this.lastMotion = Pin8 == PinState.HIGH;
MainPage.Instance.DigitalPinUpdated(8, Pin8);
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.arduino.digitalWrite(9, 0); // Relay set to 0
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
MainPage.Instance.AnalogPinUpdated("A0", this.arduino.analogRead("A0"));
this.sampleTimer = new Timer(this.SampleValues, null, 1000 - DateTime.Now.Millisecond, 1000);
};
this.arduino.AnalogPinUpdated += (pin, value) =>
{
MainPage.Instance.AnalogPinUpdated(pin, value);
};
this.arduino.DigitalPinUpdated += (pin, value) =>
{
MainPage.Instance.DigitalPinUpdated(pin, value);
if (pin == 8)
{
this.PublishMotion(value == PinState.HIGH);
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
this.mqttClient = new MqttClient("iot.eclipse.org", 8883, true, this.deviceId, string.Empty);
//this.mqttClient = new MqttClient("iot.eclipse.org", 8883, true, this.deviceId, string.Empty, new LogSniffer());
this.mqttClient.OnStateChanged += (sender, state) => Log.Informational("MQTT client state changed: " + state.ToString());
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async Task <DeviceInformation> FindFirstArduinoBoard()
{
var usbDevices = await UsbSerial.listAvailableDevicesAsync();
return(usbDevices.FirstOrDefault(d => d.Name.ToUpper().Contains("ARDUINO")));
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
instance = this;
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(IContentEncoder).GetTypeInfo().Assembly,
typeof(ImageCodec).GetTypeInfo().Assembly,
typeof(MarkdownDocument).GetTypeInfo().Assembly,
typeof(MarkdownToHtmlConverter).GetTypeInfo().Assembly,
typeof(JwsAlgorithm).GetTypeInfo().Assembly,
typeof(Expression).GetTypeInfo().Assembly,
typeof(Graph).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
Database.Register(new FilesProvider(ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000));
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo is null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += () =>
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
PinState Pin8 = this.arduino.digitalRead(8);
this.lastMotion = Pin8 == PinState.HIGH;
MainPage.Instance.DigitalPinUpdated(8, Pin8);
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.arduino.digitalWrite(9, 0); // Relay set to 0
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
MainPage.Instance.AnalogPinUpdated("A0", this.arduino.analogRead("A0"));
this.sampleTimer = new Timer(this.SampleValues, null, 1000 - DateTime.Now.Millisecond, 1000);
};
this.arduino.AnalogPinUpdated += (pin, value) =>
{
MainPage.Instance.AnalogPinUpdated(pin, value);
};
this.arduino.DigitalPinUpdated += (pin, value) =>
{
MainPage.Instance.DigitalPinUpdated(pin, value);
if (pin == 8)
{
this.lastMotion = (value == PinState.HIGH);
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
this.tokenAuthentication = new JwtAuthentication(this.deviceId, this.users, this.tokenFactory);
this.httpServer = new HttpServer();
//this.httpServer = new HttpServer(new LogSniffer());
StorageFile File = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Root/favicon.ico"));
string Root = File.Path;
Root = Root.Substring(0, Root.Length - 11);
this.httpServer.Register(new HttpFolderResource(string.Empty, Root, false, false, true, true));
this.httpServer.Register("/", (req, resp) =>
{
throw new TemporaryRedirectException("/Index.md");
});
this.httpServer.Register("/Momentary", (req, resp) =>
{
resp.SetHeader("Cache-Control", "max-age=0, no-cache, no-store");
if (req.Header.Accept != null)
{
switch (req.Header.Accept.GetBestContentType("text/xml", "application/xml", "application/json", "image/png", "image/jpeg", "image/webp"))
{
case "text/xml":
case "application/xml":
this.ReturnMomentaryAsXml(req, resp);
break;
case "application/json":
this.ReturnMomentaryAsJson(req, resp);
break;
case "image/png":
this.ReturnMomentaryAsPng(req, resp);
break;
case "image/jpg":
this.ReturnMomentaryAsJpg(req, resp);
break;
case "image/webp":
this.ReturnMomentaryAsWebp(req, resp);
break;
default:
throw new NotAcceptableException();
}
}
else
{
this.ReturnMomentaryAsXml(req, resp);
}
}, this.tokenAuthentication);
this.httpServer.Register("/MomentaryPng", (req, resp) =>
{
IUser User;
if (!req.Session.TryGetVariable("User", out Variable v) ||
(User = v.ValueObject as IUser) is null)
{
throw new ForbiddenException();
}
resp.SetHeader("Cache-Control", "max-age=0, no-cache, no-store");
this.ReturnMomentaryAsPng(req, resp);
}, true, false, true);
this.httpServer.Register("/Login", null, (req, resp) =>
{
if (!req.HasData || req.Session is null)
{
throw new BadRequestException();
}
object Obj = req.DecodeData();
if (!(Obj is Dictionary <string, string> Form) ||
!Form.TryGetValue("UserName", out string UserName) ||
!Form.TryGetValue("Password", out string Password))
{
throw new BadRequestException();
}
string From = null;
if (req.Session.TryGetVariable("from", out Variable v))
{
From = v.ValueObject as string;
}
if (string.IsNullOrEmpty(From))
{
From = "/Index.md";
}
IUser User = this.Login(UserName, Password);
if (User != null)
{
Log.Informational("User logged in.", UserName, req.RemoteEndPoint, "LoginSuccessful", EventLevel.Minor);
req.Session["User"] = User;
req.Session.Remove("LoginError");
throw new SeeOtherException(From);
}
else
{
Log.Warning("Invalid login attempt.", UserName, req.RemoteEndPoint, "LoginFailure", EventLevel.Minor);
req.Session["LoginError"] = "Invalid login credentials provided.";
}
throw new SeeOtherException(req.Header.Referer.Value);
}, true, false, true);
this.httpServer.Register("/GetSessionToken", null, (req, resp) =>
{
IUser User;
if (!req.Session.TryGetVariable("User", out Variable v) ||
(User = v.ValueObject as IUser) is null)
{
throw new ForbiddenException();
}
string Token = this.tokenFactory.Create(new KeyValuePair <string, object>("sub", User.UserName));
resp.ContentType = JwtCodec.ContentType;
resp.Write(Token);
}, true, false, true);
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(IContentEncoder).GetTypeInfo().Assembly,
typeof(XmppClient).GetTypeInfo().Assembly,
typeof(Waher.Content.Markdown.MarkdownDocument).GetTypeInfo().Assembly,
typeof(XML).GetTypeInfo().Assembly,
typeof(Waher.Script.Expression).GetTypeInfo().Assembly,
typeof(Waher.Script.Graphs.Graph).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
Database.Register(new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000));
#if GPIO
gpio = GpioController.GetDefault();
if (gpio != null)
{
if (gpio.TryOpenPin(gpioOutputPin, GpioSharingMode.Exclusive, out this.gpioPin, out GpioOpenStatus Status) &&
Status == GpioOpenStatus.PinOpened)
{
if (this.gpioPin.IsDriveModeSupported(GpioPinDriveMode.Output))
{
this.gpioPin.SetDriveMode(GpioPinDriveMode.Output);
this.output = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.gpioPin.Write(this.output ? GpioPinValue.High : GpioPinValue.Low);
await MainPage.Instance.OutputSet(this.output);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", this.output));
}
else
{
Log.Error("Output mode not supported for GPIO pin " + gpioOutputPin.ToString());
}
}
else
{
Log.Error("Unable to get access to GPIO pin " + gpioOutputPin.ToString());
}
}
#else
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo == null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += async() =>
{
try
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.output = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.arduino.digitalWrite(9, this.output.Value ? PinState.HIGH : PinState.LOW);
await MainPage.Instance.OutputSet(this.output.Value);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", this.output));
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
#endif
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
string Host = await RuntimeSettings.GetAsync("XmppHost", "waher.se");
int Port = (int)await RuntimeSettings.GetAsync("XmppPort", 5222);
string UserName = await RuntimeSettings.GetAsync("XmppUserName", string.Empty);
string PasswordHash = await RuntimeSettings.GetAsync("XmppPasswordHash", string.Empty);
string PasswordHashMethod = await RuntimeSettings.GetAsync("XmppPasswordHashMethod", string.Empty);
if (string.IsNullOrEmpty(Host) ||
Port <= 0 || Port > ushort.MaxValue ||
string.IsNullOrEmpty(UserName) ||
string.IsNullOrEmpty(PasswordHash) ||
string.IsNullOrEmpty(PasswordHashMethod))
{
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await this.ShowConnectionDialog(Host, Port, UserName));
}
else
{
this.xmppClient = new XmppClient(Host, Port, UserName, PasswordHash, PasswordHashMethod, "en",
typeof(App).GetTypeInfo().Assembly) // Add "new LogSniffer()" to the end, to output communication to the log.
{
AllowCramMD5 = false,
AllowDigestMD5 = false,
AllowPlain = false,
AllowScramSHA1 = true
};
this.xmppClient.OnStateChanged += this.StateChanged;
this.xmppClient.OnConnectionError += this.ConnectionError;
this.AttachFeatures();
Log.Informational("Connecting to " + this.xmppClient.Host + ":" + this.xmppClient.Port.ToString());
this.xmppClient.Connect();
}
this.minuteTimer = new Timer((State) =>
{
if (this.xmppClient != null &&
(this.xmppClient.State == XmppState.Error || this.xmppClient.State == XmppState.Offline))
{
this.xmppClient.Reconnect();
}
}, null, 60000, 60000);
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(ObjectSerializer).GetTypeInfo().Assembly, // Waher.Persistence.Serialization was broken out of Waher.Persistence.FilesLW after the publishing of the MIoT book.
typeof(App).GetTypeInfo().Assembly);
db = await FilesProvider.CreateAsync(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000);
Database.Register(db);
await db.RepairIfInproperShutdown(null);
await db.Start();
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo is null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += () =>
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
MainPage.Instance.DigitalPinUpdated(8, this.arduino.digitalRead(8));
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.arduino.digitalWrite(9, 0); // Relay set to 0
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
MainPage.Instance.AnalogPinUpdated("A0", this.arduino.analogRead("A0"));
this.sampleTimer = new Timer(this.SampleValues, null, 1000 - DateTime.Now.Millisecond, 1000);
};
this.arduino.AnalogPinUpdated += (pin, value) =>
{
MainPage.Instance.AnalogPinUpdated(pin, value);
};
this.arduino.DigitalPinUpdated += (pin, value) =>
{
MainPage.Instance.DigitalPinUpdated(pin, value);
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(ObjectSerializer).GetTypeInfo().Assembly, // Waher.Persistence.Serialization was broken out of Waher.Persistence.FilesLW after the publishing of the MIoT book.
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(IContentEncoder).GetTypeInfo().Assembly,
typeof(ImageCodec).GetTypeInfo().Assembly,
typeof(MarkdownDocument).GetTypeInfo().Assembly,
typeof(MarkdownToHtmlConverter).GetTypeInfo().Assembly,
typeof(IJwsAlgorithm).GetTypeInfo().Assembly,
typeof(Expression).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
db = new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000);
Database.Register(db);
await db.RepairIfInproperShutdown(null);
await db.Start();
#if GPIO
gpio = GpioController.GetDefault();
if (gpio != null)
{
if (gpio.TryOpenPin(gpioOutputPin, GpioSharingMode.Exclusive, out this.gpioPin, out GpioOpenStatus Status) &&
Status == GpioOpenStatus.PinOpened)
{
if (this.gpioPin.IsDriveModeSupported(GpioPinDriveMode.Output))
{
this.gpioPin.SetDriveMode(GpioPinDriveMode.Output);
this.output = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.gpioPin.Write(this.output.Value ? GpioPinValue.High : GpioPinValue.Low);
await MainPage.Instance.OutputSet(this.output.Value);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", this.output.Value));
}
else
{
Log.Error("Output mode not supported for GPIO pin " + gpioOutputPin.ToString());
}
}
else
{
Log.Error("Unable to get access to GPIO pin " + gpioOutputPin.ToString());
}
}
#else
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo is null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += async() =>
{
try
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.output = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.arduino.digitalWrite(9, this.output.Value ? PinState.HIGH : PinState.LOW);
await MainPage.Instance.OutputSet(this.output.Value);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", this.output.Value));
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
#endif
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
this.tokenAuthentication = new JwtAuthentication(this.deviceId, this.users, this.tokenFactory);
this.httpServer = new HttpServer();
//this.httpServer = new HttpServer(new LogSniffer());
StorageFile File = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Assets/Root/favicon.ico"));
string Root = File.Path;
Root = Root.Substring(0, Root.Length - 11);
this.httpServer.Register(new HttpFolderResource(string.Empty, Root, false, false, true, true));
this.httpServer.Register("/", (req, resp) =>
{
throw new TemporaryRedirectException("/Index.md");
});
this.httpServer.Register("/Momentary", (req, resp) =>
{
resp.SetHeader("Cache-Control", "max-age=0, no-cache, no-store");
if (req.Header.Accept != null)
{
switch (req.Header.Accept.GetBestAlternative("text/xml", "application/xml", "application/json"))
{
case "text/xml":
case "application/xml":
this.ReturnMomentaryAsXml(req, resp);
break;
case "application/json":
this.ReturnMomentaryAsJson(req, resp);
break;
default:
throw new NotAcceptableException();
}
}
else
{
this.ReturnMomentaryAsXml(req, resp);
}
return(Task.CompletedTask);
}, this.tokenAuthentication);
this.httpServer.Register("/Set", null, async(req, resp) =>
{
try
{
if (!req.HasData)
{
throw new BadRequestException();
}
if (!(req.DecodeData() is string s) || !CommonTypes.TryParse(s, out bool OutputValue))
{
throw new BadRequestException();
}
if (req.Header.Accept != null)
{
switch (req.Header.Accept.GetBestAlternative("text/xml", "application/xml", "application/json"))
{
case "text/xml":
case "application/xml":
await this.SetOutput(OutputValue, req.RemoteEndPoint);
this.ReturnMomentaryAsXml(req, resp);
break;
case "application/json":
await this.SetOutput(OutputValue, req.RemoteEndPoint);
this.ReturnMomentaryAsJson(req, resp);
break;
default:
throw new NotAcceptableException();
}
}
else
{
await this.SetOutput(OutputValue, req.RemoteEndPoint);
this.ReturnMomentaryAsXml(req, resp);
}
await resp.SendResponse();
}
catch (Exception ex)
{
await resp.SendResponse(ex);
}
}, false, this.tokenAuthentication);
this.httpServer.Register("/Login", null, (req, resp) =>
{
if (!req.HasData || req.Session is null)
{
throw new BadRequestException();
}
object Obj = req.DecodeData();
if (!(Obj is Dictionary <string, string> Form) ||
!Form.TryGetValue("UserName", out string UserName) ||
!Form.TryGetValue("Password", out string Password))
{
throw new BadRequestException();
}
string From = null;
if (req.Session.TryGetVariable("from", out Variable v))
{
From = v.ValueObject as string;
}
if (string.IsNullOrEmpty(From))
{
From = "/Index.md";
}
IUser User = this.Login(UserName, Password);
if (User != null)
{
Log.Informational("User logged in.", UserName, req.RemoteEndPoint, "LoginSuccessful", EventLevel.Minor);
req.Session["User"] = User;
req.Session.Remove("LoginError");
throw new SeeOtherException(From);
}
else
{
Log.Warning("Invalid login attempt.", UserName, req.RemoteEndPoint, "LoginFailure", EventLevel.Minor);
req.Session["LoginError"] = "Invalid login credentials provided.";
}
throw new SeeOtherException(req.Header.Referer.Value);
}, true, false, true);
this.httpServer.Register("/GetSessionToken", null, (req, resp) =>
{
if (!req.Session.TryGetVariable("User", out Variable v) ||
!(v.ValueObject is IUser User))
{
throw new ForbiddenException();
}
string Token = this.tokenFactory.Create(new KeyValuePair <string, object>("sub", User.UserName));
resp.ContentType = JwtCodec.ContentType;
resp.Write(Token);
return(Task.CompletedTask);
}, true, false, true);
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(IContentEncoder).GetTypeInfo().Assembly,
typeof(ICoapContentFormat).GetTypeInfo().Assembly,
typeof(IDtlsCredentials).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
db = new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000);
Database.Register(db);
await db.RepairIfInproperShutdown(null);
await db.Start();
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo is null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += () =>
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
PinState Pin8 = this.arduino.digitalRead(8);
this.lastMotion = Pin8 == PinState.HIGH;
MainPage.Instance.DigitalPinUpdated(8, Pin8);
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.arduino.digitalWrite(9, 0); // Relay set to 0
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
MainPage.Instance.AnalogPinUpdated("A0", this.arduino.analogRead("A0"));
this.sampleTimer = new Timer(this.SampleValues, null, 1000 - DateTime.Now.Millisecond, 1000);
};
this.arduino.AnalogPinUpdated += (pin, value) =>
{
MainPage.Instance.AnalogPinUpdated(pin, value);
};
this.arduino.DigitalPinUpdated += (pin, value) =>
{
MainPage.Instance.DigitalPinUpdated(pin, value);
if (pin == 8)
{
this.lastMotion = (value == PinState.HIGH);
this.motionResource?.TriggerAll();
this.momentaryResource?.TriggerAll();
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
/************************************************************************************
* To create an unencrypted CoAP Endpoint on the default CoAP port:
*
* this.coapEndpoint = new CoapEndpoint();
*
* To create an unencrypted CoAP Endpoint on the default CoAP port,
* with a sniffer that outputs communication to the window:
*
* this.coapEndpoint = new CoapEndpoint(new LogSniffer());
*
* To create a DTLS encrypted CoAP endpoint, on the default CoAPS port, using
* the users defined in the IUserSource users:
*
* this.coapEndpoint = new CoapEndpoint(CoapEndpoint.DefaultCoapsPort, this.users);
*
* To create a CoAP endpoint, that listens to both the default CoAP port, for
* unencrypted communication, and the default CoAPS port, for encrypted,
* authenticated and authorized communication, using
* the users defined in the IUserSource users. Only users having the given
* privilege (if not empty) will be authorized to access resources on the endpoint:
*
* this.coapEndpoint = new CoapEndpoint(new int[] { CoapEndpoint.DefaultCoapPort },
* new int[] { CoapEndpoint.DefaultCoapsPort }, this.users, "PRIVILEGE", false, false);
*
************************************************************************************/
this.coapEndpoint = new CoapEndpoint(new int[] { CoapEndpoint.DefaultCoapPort },
new int[] { CoapEndpoint.DefaultCoapsPort }, this.users, string.Empty, false, false);
this.lightResource = this.coapEndpoint.Register("/Light", (req, resp) =>
{
string s;
if (this.lastLight.HasValue)
{
s = ToString(this.lastLight.Value, 2) + " %";
}
else
{
s = "-";
}
resp.Respond(CoapCode.Content, s, 64);
}, Notifications.Unacknowledged, "Light, in %.", null, null,
new int[] { PlainText.ContentFormatCode });
this.lightResource?.TriggerAll(new TimeSpan(0, 0, 5));
this.motionResource = this.coapEndpoint.Register("/Motion", (req, resp) =>
{
string s;
if (this.lastMotion.HasValue)
{
s = this.lastMotion.Value ? "true" : "false";
}
else
{
s = "-";
}
resp.Respond(CoapCode.Content, s, 64);
}, Notifications.Acknowledged, "Motion detector.", null, null,
new int[] { PlainText.ContentFormatCode });
this.motionResource?.TriggerAll(new TimeSpan(0, 1, 0));
this.momentaryResource = this.coapEndpoint.Register("/Momentary", (req, resp) =>
{
if (req.IsAcceptable(Xml.ContentFormatCode))
{
this.ReturnMomentaryAsXml(req, resp);
}
else if (req.IsAcceptable(Json.ContentFormatCode))
{
this.ReturnMomentaryAsJson(req, resp);
}
else if (req.IsAcceptable(PlainText.ContentFormatCode))
{
this.ReturnMomentaryAsPlainText(req, resp);
}
else if (req.Accept.HasValue)
{
throw new CoapException(CoapCode.NotAcceptable);
}
else
{
this.ReturnMomentaryAsPlainText(req, resp);
}
}, Notifications.Acknowledged, "Momentary values.", null, null,
new int[] { Xml.ContentFormatCode, Json.ContentFormatCode, PlainText.ContentFormatCode });
this.momentaryResource?.TriggerAll(new TimeSpan(0, 0, 5));
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(IContentEncoder).GetTypeInfo().Assembly,
typeof(ICoapContentFormat).GetTypeInfo().Assembly,
typeof(IDtlsCredentials).GetTypeInfo().Assembly,
typeof(Lwm2mClient).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
Database.Register(new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000));
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
foreach (DeviceInformation DeviceInfo in Devices)
{
if (DeviceInfo.IsEnabled && DeviceInfo.Name.StartsWith("Arduino"))
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += () =>
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(0, PinMode.INPUT); // PIR sensor (motion detection).
PinState Pin0 = this.arduino.digitalRead(0);
this.lastMotion = Pin0 == PinState.HIGH;
MainPage.Instance.DigitalPinUpdated(0, Pin0);
this.arduino.pinMode(1, PinMode.OUTPUT); // Relay.
this.arduino.digitalWrite(1, 0); // Relay set to 0
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
MainPage.Instance.AnalogPinUpdated("A0", this.arduino.analogRead("A0"));
this.sampleTimer = new Timer(this.SampleValues, null, 1000 - DateTime.Now.Millisecond, 1000);
};
this.arduino.AnalogPinUpdated += (pin, value) =>
{
MainPage.Instance.AnalogPinUpdated(pin, value);
};
this.arduino.DigitalPinUpdated += (pin, value) =>
{
MainPage.Instance.DigitalPinUpdated(pin, value);
if (pin == 0)
{
bool Input = (value == PinState.HIGH);
this.lastMotion = Input;
this.digitalInput0?.Set(Input);
this.presenceSensor0?.Set(Input);
this.genericSensor0?.Set(Input ? 1.0 : 0.0);
this.motionResource?.TriggerAll();
this.momentaryResource?.TriggerAll();
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
break;
}
}
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
/************************************************************************************
* To create an unencrypted CoAP Endpoint on the default CoAP port:
*
* this.coapEndpoint = new CoapEndpoint();
*
* To create an unencrypted CoAP Endpoint on the default CoAP port,
* with a sniffer that outputs communication to the window:
*
* this.coapEndpoint = new CoapEndpoint(new LogSniffer());
*
* To create a DTLS encrypted CoAP endpoint, on the default CoAPS port, using
* the users defined in the IUserSource users:
*
* this.coapEndpoint = new CoapEndpoint(CoapEndpoint.DefaultCoapsPort, this.users);
*
* To create a CoAP endpoint, that listens to both the default CoAP port, for
* unencrypted communication, and the default CoAPS port, for encrypted,
* authenticated and authorized communication, using
* the users defined in the IUserSource users. Only users having the given
* privilege (if not empty) will be authorized to access resources on the endpoint:
*
* this.coapEndpoint = new CoapEndpoint(new int[] { CoapEndpoint.DefaultCoapPort },
* new int[] { CoapEndpoint.DefaultCoapsPort }, this.users, "PRIVILEGE", false, false);
*
************************************************************************************/
//this.coapEndpoint = new CoapEndpoint(new int[] { CoapEndpoint.DefaultCoapPort },
// new int[] { CoapEndpoint.DefaultCoapsPort }, this.users, string.Empty, false, false);
this.coapEndpoint = new CoapEndpoint(new int[] { 5783 }, new int[] { 5784 }, null, null,
false, false);
this.lightResource = this.coapEndpoint.Register("/Light", (req, resp) =>
{
string s;
if (this.lastLight.HasValue)
{
s = ToString(this.lastLight.Value, 2) + " %";
}
else
{
s = "-";
}
resp.Respond(CoapCode.Content, s, 64);
}, Notifications.Unacknowledged, "Light, in %.", null, null,
new int[] { PlainText.ContentFormatCode });
this.lightResource?.TriggerAll(new TimeSpan(0, 0, 5));
this.motionResource = this.coapEndpoint.Register("/Motion", (req, resp) =>
{
string s;
if (this.lastMotion.HasValue)
{
s = this.lastMotion.Value ? "true" : "false";
}
else
{
s = "-";
}
resp.Respond(CoapCode.Content, s, 64);
}, Notifications.Acknowledged, "Motion detector.", null, null,
new int[] { PlainText.ContentFormatCode });
this.motionResource?.TriggerAll(new TimeSpan(0, 1, 0));
this.momentaryResource = this.coapEndpoint.Register("/Momentary", (req, resp) =>
{
if (req.IsAcceptable(Xml.ContentFormatCode))
{
this.ReturnMomentaryAsXml(req, resp);
}
else if (req.IsAcceptable(Json.ContentFormatCode))
{
this.ReturnMomentaryAsJson(req, resp);
}
else if (req.IsAcceptable(PlainText.ContentFormatCode))
{
this.ReturnMomentaryAsPlainText(req, resp);
}
else if (req.Accept.HasValue)
{
throw new CoapException(CoapCode.NotAcceptable);
}
else
{
this.ReturnMomentaryAsPlainText(req, resp);
}
}, Notifications.Acknowledged, "Momentary values.", null, null,
new int[] { Xml.ContentFormatCode, Json.ContentFormatCode, PlainText.ContentFormatCode });
this.momentaryResource?.TriggerAll(new TimeSpan(0, 0, 5));
this.lwm2mClient = new Lwm2mClient("MIoT:Sensor:" + this.deviceId, this.coapEndpoint,
new Lwm2mSecurityObject(),
new Lwm2mServerObject(),
new Lwm2mAccessControlObject(),
new Lwm2mDeviceObject("Waher Data AB", "SensorLwm2m", this.deviceId, "1.0", "Sensor", "1.0", "1.0"),
new DigitalInput(this.digitalInput0 = new DigitalInputInstance(0, this.lastMotion, "Motion Detector", "PIR")),
new AnalogInput(this.analogInput0 = new AnalogInputInstance(0, this.lastLight, 0, 100, "Ambient Light Sensor", "%")),
new GenericSensor(this.genericSensor0 = new GenericSensorInstance(0, null, string.Empty, 0, 1, "Motion Detector", "PIR"),
this.genericSensor1 = new GenericSensorInstance(1, this.lastLight, "%", 0, 100, "Ambient Light Sensor", "%")),
new IlluminanceSensor(this.illuminanceSensor0 = new IlluminanceSensorInstance(0, this.lastLight, "%", 0, 100)),
new PresenceSensor(this.presenceSensor0 = new PresenceSensorInstance(0, this.lastMotion, "PIR")),
new PercentageSensor(this.percentageSensor0 = new PercentageSensorInstance(0, this.lastLight, 0, 100, "Ambient Light Sensor")));
await this.lwm2mClient.LoadBootstrapInfo();
this.lwm2mClient.OnStateChanged += (sender, e) =>
{
Log.Informational("LWM2M state changed to " + this.lwm2mClient.State.ToString() + ".");
};
this.lwm2mClient.OnBootstrapCompleted += (sender, e) =>
{
Log.Informational("Bootstrap procedure completed.");
};
this.lwm2mClient.OnBootstrapFailed += (sender, e) =>
{
Log.Error("Bootstrap procedure failed.");
this.coapEndpoint.ScheduleEvent(async(P) =>
{
try
{
await this.RequestBootstrap();
}
catch (Exception ex)
{
Log.Critical(ex);
}
}, DateTime.Now.AddMinutes(15), null);
};
this.lwm2mClient.OnRegistrationSuccessful += (sender, e) =>
{
Log.Informational("Server registration completed.");
};
this.lwm2mClient.OnRegistrationFailed += (sender, e) =>
{
Log.Error("Server registration failed.");
};
this.lwm2mClient.OnDeregistrationSuccessful += (sender, e) =>
{
Log.Informational("Server deregistration completed.");
};
this.lwm2mClient.OnDeregistrationFailed += (sender, e) =>
{
Log.Error("Server deregistration failed.");
};
this.lwm2mClient.OnRebootRequest += async(sender, e) =>
{
Log.Warning("Reboot is requested.");
try
{
await this.RequestBootstrap();
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
await this.RequestBootstrap();
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await MainPage.Instance.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
async() => await Dialog.ShowAsync());
}
}
private async void Init()
{
try
{
Log.Informational("Starting application.");
Types.Initialize(
typeof(FilesProvider).GetTypeInfo().Assembly,
typeof(RuntimeSettings).GetTypeInfo().Assembly,
typeof(IContentEncoder).GetTypeInfo().Assembly,
typeof(ICoapContentFormat).GetTypeInfo().Assembly,
typeof(IDtlsCredentials).GetTypeInfo().Assembly,
typeof(Lwm2mClient).GetTypeInfo().Assembly,
typeof(App).GetTypeInfo().Assembly);
db = new FilesProvider(Windows.Storage.ApplicationData.Current.LocalFolder.Path +
Path.DirectorySeparatorChar + "Data", "Default", 8192, 1000, 8192, Encoding.UTF8, 10000);
Database.Register(db);
await db.RepairIfInproperShutdown(null);
await db.Start();
#if GPIO
gpio = GpioController.GetDefault();
if (gpio != null)
{
if (gpio.TryOpenPin(gpioOutputPin, GpioSharingMode.Exclusive, out this.gpioPin, out GpioOpenStatus Status) &&
Status == GpioOpenStatus.PinOpened)
{
if (this.gpioPin.IsDriveModeSupported(GpioPinDriveMode.Output))
{
this.gpioPin.SetDriveMode(GpioPinDriveMode.Output);
this.output = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.gpioPin.Write(this.output.Value ? GpioPinValue.High : GpioPinValue.Low);
this.digitalOutput0?.Set(this.output.Value);
this.actuation0?.Set(this.output.Value);
await MainPage.Instance.OutputSet(this.output.Value);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", this.output.Value));
}
else
{
Log.Error("Output mode not supported for GPIO pin " + gpioOutputPin.ToString());
}
}
else
{
Log.Error("Unable to get access to GPIO pin " + gpioOutputPin.ToString());
}
}
#else
DeviceInformationCollection Devices = await UsbSerial.listAvailableDevicesAsync();
DeviceInformation DeviceInfo = this.FindDevice(Devices, "Arduino", "USB Serial Device");
if (DeviceInfo is null)
{
Log.Error("Unable to find Arduino device.");
}
else
{
Log.Informational("Connecting to " + DeviceInfo.Name);
this.arduinoUsb = new UsbSerial(DeviceInfo);
this.arduinoUsb.ConnectionEstablished += () =>
Log.Informational("USB connection established.");
this.arduino = new RemoteDevice(this.arduinoUsb);
this.arduino.DeviceReady += async() =>
{
try
{
Log.Informational("Device ready.");
this.arduino.pinMode(13, PinMode.OUTPUT); // Onboard LED.
this.arduino.digitalWrite(13, PinState.HIGH);
this.arduino.pinMode(8, PinMode.INPUT); // PIR sensor (motion detection).
this.arduino.pinMode(9, PinMode.OUTPUT); // Relay.
this.output = await RuntimeSettings.GetAsync("Actuator.Output", false);
this.arduino.digitalWrite(9, this.output.Value ? PinState.HIGH : PinState.LOW);
this.digitalOutput0?.Set(this.output.Value);
this.actuation0?.Set(this.output.Value);
await MainPage.Instance.OutputSet(this.output.Value);
Log.Informational("Setting Control Parameter.", string.Empty, "Startup",
new KeyValuePair <string, object>("Output", this.output.Value));
this.arduino.pinMode("A0", PinMode.ANALOG); // Light sensor.
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
this.arduinoUsb.ConnectionFailed += message =>
{
Log.Error("USB connection failed: " + message);
};
this.arduinoUsb.ConnectionLost += message =>
{
Log.Error("USB connection lost: " + message);
};
this.arduinoUsb.begin(57600, SerialConfig.SERIAL_8N1);
}
#endif
this.deviceId = await RuntimeSettings.GetAsync("DeviceId", string.Empty);
if (string.IsNullOrEmpty(this.deviceId))
{
this.deviceId = Guid.NewGuid().ToString().Replace("-", string.Empty);
await RuntimeSettings.SetAsync("DeviceId", this.deviceId);
}
Log.Informational("Device ID: " + this.deviceId);
/************************************************************************************
* To create an unencrypted CoAP Endpoint on the default CoAP port:
*
* this.coapEndpoint = new CoapEndpoint();
*
* To create an unencrypted CoAP Endpoint on the default CoAP port,
* with a sniffer that outputs communication to the window:
*
* this.coapEndpoint = new CoapEndpoint(new LogSniffer());
*
* To create a DTLS encrypted CoAP endpoint, on the default CoAPS port, using
* the users defined in the IUserSource users:
*
* this.coapEndpoint = new CoapEndpoint(CoapEndpoint.DefaultCoapsPort, this.users);
*
* To create a CoAP endpoint, that listens to both the default CoAP port, for
* unencrypted communication, and the default CoAPS port, for encrypted,
* authenticated and authorized communication, using
* the users defined in the IUserSource users. Only users having the given
* privilege (if not empty) will be authorized to access resources on the endpoint:
*
* this.coapEndpoint = new CoapEndpoint(new int[] { CoapEndpoint.DefaultCoapPort },
* new int[] { CoapEndpoint.DefaultCoapsPort }, this.users, "PRIVILEGE", false, false);
*
************************************************************************************/
this.coapEndpoint = new CoapEndpoint(new int[] { CoapEndpoint.DefaultCoapPort },
new int[] { CoapEndpoint.DefaultCoapsPort }, this.users, string.Empty, false, false);
this.outputResource = this.coapEndpoint.Register("/Output", (req, resp) =>
{
string s;
if (this.output.HasValue)
{
s = this.output.Value ? "true" : "false";
}
else
{
s = "-";
}
resp.Respond(CoapCode.Content, s, 64);
}, async(req, resp) =>
{
try
{
string s = req.Decode() as string;
if (s is null && req.Payload != null)
{
s = Encoding.UTF8.GetString(req.Payload);
}
if (s is null || !CommonTypes.TryParse(s, out bool Output))
{
resp.RST(CoapCode.BadRequest);
}
else
{
resp.Respond(CoapCode.Changed);
await this.SetOutput(Output, req.From.ToString());
}
}
catch (Exception ex)
{
Log.Critical(ex);
}
}, Notifications.Acknowledged, "Digital Output.", null, null,
private void RefreshDeviceList()
{
//invoke the listAvailableDevicesAsync method of the correct Serial class. Since it is Async, we will wrap it in a Task and add a llambda to execute when finished
Task <DeviceInformationCollection> task = null;
if (ConnectionMethodComboBox.SelectedItem == null)
{
ConnectMessage.Text = "Select a connection method to continue.";
return;
}
switch (ConnectionMethodComboBox.SelectedItem as String)
{
default:
case "Bluetooth":
ConnectionList.Visibility = Visibility.Visible;
DevicesText.Visibility = Visibility.Visible;
NetworkHostNameTextBox.IsEnabled = false;
NetworkPortTextBox.IsEnabled = false;
BaudRateComboBox.IsEnabled = true;
NetworkHostNameTextBox.Text = "";
NetworkPortTextBox.Text = "";
//create a cancellation token which can be used to cancel a task
cancelTokenSource = new CancellationTokenSource();
cancelTokenSource.Token.Register(() => OnConnectionCancelled());
task = BluetoothSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>(cancelTokenSource.Token);
break;
case "USB":
ConnectionList.Visibility = Visibility.Visible;
DevicesText.Visibility = Visibility.Visible;
NetworkHostNameTextBox.IsEnabled = false;
NetworkPortTextBox.IsEnabled = false;
BaudRateComboBox.IsEnabled = true;
NetworkHostNameTextBox.Text = "";
NetworkPortTextBox.Text = "";
//create a cancellation token which can be used to cancel a task
cancelTokenSource = new CancellationTokenSource();
cancelTokenSource.Token.Register(() => OnConnectionCancelled());
task = UsbSerial.listAvailableDevicesAsync().AsTask <DeviceInformationCollection>(cancelTokenSource.Token);
break;
case "Network":
ConnectionList.Visibility = Visibility.Collapsed;
DevicesText.Visibility = Visibility.Collapsed;
NetworkHostNameTextBox.IsEnabled = true;
NetworkPortTextBox.IsEnabled = true;
BaudRateComboBox.IsEnabled = false;
ConnectMessage.Text = "Enter a host and port to connect.";
task = null;
break;
}
if (task != null)
{
//store the returned DeviceInformation items when the task completes
task.ContinueWith(listTask =>
{
//store the result and populate the device list on the UI thread
var action = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() =>
{
Connections connections = new Connections();
var result = listTask.Result;
if (result == null || result.Count == 0)
{
ConnectMessage.Text = "No items found.";
ConnectionList.Visibility = Visibility.Collapsed;
}
else
{
foreach (DeviceInformation device in result)
{
connections.Add(new Connection(device.Name, device));
}
ConnectMessage.Text = "Select an item and press \"Connect\" to connect.";
}
ConnectionList.ItemsSource = connections;
}));
});
}
}