protected internal virtual void Initialize(XmlSerializer serializer, Service service)
{
if (serializer == null)
{
throw new ArgumentNullException("serializer");
}
else if (service == null)
{
throw new ArgumentNullException("service");
}
else if (service.ScpdUrl == null)
{
throw new ArgumentException("The service has no ScpdUrl.", "service");
}
else if (service.ControlUrl == null)
{
throw new ArgumentException("The service has no ControlUrl.", "service");
}
else if (service.EventUrl == null)
{
throw new ArgumentException("The service has no EventUrl.", "service");
}
scpd_server = new DataServer(serializer.GetBytes(this), @"text/xml; charset=""utf-8""", service.ScpdUrl);
control_server = new ControlServer(actions, service.Type.ToString(), service.ControlUrl, serializer);
event_server = new EventServer(state_variables.Values, service.EventUrl);
foreach (var state_variable in state_variables.Values)
{
state_variable.Initialize(this);
}
}
/// <summary>
/// Adds the extension to the client.
/// </summary>
/// <param name="Instance">Actor instance.</param>
/// <param name="Client">XMPP Client</param>
/// <returns>Extension object.</returns>
public override Task <object> Add(IActor Instance, Waher.Networking.XMPP.XmppClient Client)
{
ControlServer Extension;
if (Client.TryGetTag("ProvisioningClient", out object Obj) && Obj is ProvisioningClient ProvisioningClient)
{
Extension = new ControlServer(Client, ProvisioningClient);
}
else
{
Extension = new ControlServer(Client);
}
Client.SetTag("ControlServer", Extension);
Extension.OnGetControlParameters += (Node) =>
{
this.Model.ExternalEvent(Instance, "OnGetControlParameters",
new KeyValuePair <string, object>("Node", Node),
new KeyValuePair <string, object>("Client", Client));
List <ControlParameter> Parameters = new List <ControlParameter>();
foreach (ControlParameterNode Parameter in this.parameters)
{
Parameter.AddParameters(Parameters, Instance);
}
return(Task.FromResult <ControlParameter[]>(Parameters.ToArray()));
};
return(Task.FromResult <object>(Extension));
}
public static void Main()
{
// Create the blocks
var leftLight = new DigitalOutputPin(Pins.GPIO_PIN_D10)
{
Name = "LeftLight"
};
var rightLight = new DigitalOutputPin(Pins.GPIO_PIN_D11)
{
Name = "RightLight"
};
// Init
leftLight.Input.Value = 0;
rightLight.Input.Value = 0;
// Create the control server
var serialPort = new SerialPort(SerialPorts.COM3, 57600, Parity.None, 8, StopBits.One);
serialPort.Open();
var server = new ControlServer(serialPort);
// Expose the left and right lights to the control server
leftLight.Input.ConnectTo(server, writeable: true);
rightLight.Input.ConnectTo(server, writeable: true);
// Do nothing
for (; ;)
{
System.Threading.Thread.Sleep(1000);
}
}
/// <summary>
/// Adds the extension to the client.
/// </summary>
/// <param name="Instance">Actor instance.</param>
/// <param name="Client">XMPP Client</param>
public override Task Add(IActor Instance, Waher.Networking.XMPP.XmppClient Client)
{
ControlServer Extension;
if (Client.TryGetTag("ProvisioningClient", out object Obj) && Obj is ProvisioningClient ProvisioningClient)
{
Extension = new ControlServer(Client, ProvisioningClient);
}
else
{
Extension = new ControlServer(Client);
}
Client.SetTag("ControlServer", Extension);
Extension.OnGetControlParameters += (Node) =>
{
this.Model.ExternalEvent(Instance, "OnGetControlParameters",
new KeyValuePair <string, object>("Node", Node),
new KeyValuePair <string, object>("Client", Client));
return(Task.FromResult <ControlParameter[]>(new ControlParameter[0]));
};
return(Task.CompletedTask);
}
public static void updateSettings(int webServerPort, int controlServerPort, string webServerRoot, string[] webServerDefaultPages, bool webServerDirectoryBrowsing)
{
webServer.close();
controlServer.close();
webServer = new WebServer(webServerPort, webServerRoot, webServerDefaultPages, webServerDirectoryBrowsing);
controlServer = new ControlServer(controlServerPort);
}
/// <summary>
/// Performs the control operation.
/// </summary>
/// <returns>If the operation was successful or not.</returns>
public override bool Set()
{
bool Result = this.parameter.Set(this.Node, this.value);
if (!Result)
{
ControlServer.ParameterValueInvalid(this.parameter.Name, this.Request);
}
return(Result);
}
/// <summary>
/// Performs the control operation.
/// </summary>
/// <returns>If the operation was successful or not.</returns>
public override bool Set()
{
bool Result = this.parameter.SetStringValue(this.Node, this.value);
if (!Result)
{
ControlServer.ParameterSyntaxError(this.parameter.Name, this.Request);
}
return(Result);
}
public static void Main()
{
//
// Controls server
//
// initialize the serial port for COM1 (using D0 & D1)
// initialize the serial port for COM3 (using D7 & D8)
var serialPort = new SerialPort(SerialPorts.COM3, 57600, Parity.None, 8, StopBits.One);
serialPort.Open();
var server = new ControlServer(serialPort);
//
// Just some diagnostic stuff
//
var uptimeVar = server.RegisterVariable("Uptime (s)", 0);
var lv = false;
var led = new Microsoft.SPOT.Hardware.OutputPort(Pins.ONBOARD_LED, lv);
//
// Make the robot
//
var leftMotor = HBridgeMotor.CreateForNetduino(PWMChannels.PWM_PIN_D3, Pins.GPIO_PIN_D1, Pins.GPIO_PIN_D2);
var rightMotor = HBridgeMotor.CreateForNetduino(PWMChannels.PWM_PIN_D6, Pins.GPIO_PIN_D4, Pins.GPIO_PIN_D5);
var robot = new TwoWheeledRobot(leftMotor, rightMotor);
//
// Expose some variables to control it
//
robot.SpeedInput.ConnectTo(server, writeable: true, name: "Speed");
robot.DirectionInput.ConnectTo(server, writeable: true, name: "Turn");
leftMotor.SpeedInput.ConnectTo(server);
rightMotor.SpeedInput.ConnectTo(server);
//
// Show diagnostics
//
for (var i = 0; true; i++)
{
uptimeVar.Value = i;
led.Write(lv);
lv = !lv;
Thread.Sleep(1000);
}
}
// public static string GetProjectBuildFileName(IBuildDefinition definition)
// {
// return string.Format("{0}/{1}", definition.ConfigurationFolderPath, BUILD_FILE);
// }
public static Item GetProjectBuildFileItem(IBuildDefinition definition)
{
//string query = definition.ConfigurationFolderPath + "/" + BUILD_FILE;
string configurationFolderPath = definition.GetConfigurationFolderPath();
string query = configurationFolderPath + "/" + BUILD_FILE;
ItemSet items = ControlServer.GetItems(query, VersionSpec.Latest,
RecursionType.Full, DeletedState.NonDeleted, ItemType.File);
if (items.Items.Length == 1)
{
return(items.Items[0]);
}
return(null);
}
private static void initServer()
{
int webPort = 0, controlPort = 0;
string webRoot;
List <String> defaultpages = new List <String>();
bool directoryBrowsing;
XmlDocument settingsDoc = new XmlDocument();
settingsDoc.Load(settingsFilePath);
XmlElement settingsElement = settingsDoc.DocumentElement;
XmlNodeList settingsNodes = settingsElement.ChildNodes;
XmlNode webServerNode = settingsElement.GetElementsByTagName("WebServer")[0];
int.TryParse(webServerNode.Attributes[0].Value, out webPort);
XmlNode controlServerNode = settingsElement.GetElementsByTagName("ControlServer")[0];
int.TryParse(controlServerNode.Attributes[0].Value, out controlPort);
XmlNode webbRootNode = settingsElement.GetElementsByTagName("WebRoot")[0];
webRoot = webbRootNode.Attributes[0].Value;
XmlNodeList defaultPagesNodeList = settingsElement.GetElementsByTagName("File");
foreach (XmlNode fileNode in defaultPagesNodeList)
{
defaultpages.Add(fileNode.Attributes[0].Value);
}
XmlNode directoryBrowsingNode = settingsElement.GetElementsByTagName("DirectoryBrowsing")[0];
bool.TryParse(directoryBrowsingNode.Attributes[0].Value, out directoryBrowsing);
webServer = new WebServer(webPort, webRoot, defaultpages.ToArray(), directoryBrowsing);
Console.WriteLine("Webserver (127.0.0.1:" + webPort + ") listening...");
controlServer = new ControlServer(controlPort);
Console.WriteLine("Controlserver (127.0.0.1: " + controlPort + ") listening...");
Logger.Logger logger = Logger.Logger.Instance;
Console.WriteLine("Logger started...");
Console.Read();
}
public override void DisposeClients()
{
if (this.controlServer != null)
{
this.controlServer.Dispose();
this.controlServer = null;
}
if (this.controlClient != null)
{
this.controlClient.Dispose();
this.controlClient = null;
}
base.DisposeClients();
}
private void btn_set_me_Click(object sender, EventArgs e)
{
string ip = tbox_me_ip.Text;
int port = int.Parse(tbox_me_port.Text);
ControlServer cs = new ControlServer(ip, port);
cs.AddedLine += Cs_AddedLine;
cs.AddedWafer += Cs_AddedWafer;
cs.AddedPR += Cs_AddedPR;
cs.SettedSpeed += Cs_SettedSpeed;
cs.SettedDrop += Cs_SettedDrop;
cs.EndedPR += Cs_EndedPR;
cs.EndedCoating += Cs_EndedCoating;
cs.AsyncStart();
fc.SendMyInfo(ip, port);
}
public void StartServer()
{
if (server != null)
{
server.Dispose();
}
int port = 0;
if (!int.TryParse(tbPort.Text, out port) || port > 65536 || port < 1024)
{
port = 9999;
tbPort.Text = "9999";
}
server = new ControlServer(IPAddress.Any, port);
if (cbKey.IsChecked == true && tbKey.Text.Length <= 12 && tbKey.Text.Length >= 2)
{
ipmserver.AuthenticationString = tbKey.Text;
server.Executors.Add(new AuthenticateExecutor(tbKey.Text));
}
else
{
tbKey.Text = "";
ipmserver.AuthenticationString = null;
server.Executors.Add(new AuthenticateExecutor());
}
if (cbAllowMouse.IsChecked == true)
{
server.Executors.Add(new CommandExecutor());
}
if (cbAllowFileList.IsChecked == true)
{
server.Executors.Add(new FileListTransmissionExecutor());
}
if (cbAllowFileTrans.IsChecked == true)
{
server.Executors.Add(new FileTransmissionExecutor());
}
if (ipmserver.ServerStatus == ServerStatus.Stop)
{
ipmserver.Start();
}
server.Executors.Add(new DesktopTransportExecutor());
server.Listen();
}
public override void ConnectClients()
{
base.ConnectClients();
Assert.AreEqual(XmppState.Connected, this.client1.State);
Assert.AreEqual(XmppState.Connected, this.client2.State);
this.controlClient = new ControlClient(this.client1);
this.controlServer = new ControlServer(this.client2,
new BooleanControlParameter("Bool", "Page1", "Bool:", "Boolean value",
(sender) => Task.FromResult <bool?>(this.b),
(sender, value) => { this.b = value; return(Task.CompletedTask); }),
new ColorControlParameter("Color", "Page1", "Color:", "Color value",
(sender) => Task.FromResult <ColorReference>(this.cl),
(sender, value) => { this.cl = value; return(Task.CompletedTask); }),
new DateControlParameter("Date", "Page1", "Date:", "Date value", DateTime.MinValue, DateTime.MaxValue,
(sender) => Task.FromResult <DateTime?>(this.d),
(sender, value) => { this.d = value; return(Task.CompletedTask); }),
new DateTimeControlParameter("DateTime", "Page1", "DateTime:", "DateTime value", DateTime.MinValue, DateTime.MaxValue,
(sender) => Task.FromResult <DateTime?>(this.dt),
(sender, value) => { this.dt = value; return(Task.CompletedTask); }),
new DoubleControlParameter("Double", "Page1", "Double:", "Double value",
(sender) => Task.FromResult <double?>(this.db),
(sender, value) => { this.db = value; return(Task.CompletedTask); }),
new DurationControlParameter("Duration", "Page1", "Duration:", "Duration value",
(sender) => Task.FromResult <Duration>(this.dr),
(sender, value) => { this.dr = value; return(Task.CompletedTask); }),
new EnumControlParameter("Enum", "Page1", "Enum:", "Enum value", typeof(TypeCode),
(sender) => Task.FromResult <Enum>(this.e),
(sender, value) => { this.e = (TypeCode)value; return(Task.CompletedTask); }),
new Int32ControlParameter("Int32", "Page1", "Int32:", "Int32 value",
(sender) => Task.FromResult <int?>(this.i),
(sender, value) => { this.i = value; return(Task.CompletedTask); }),
new Int64ControlParameter("Int64", "Page1", "Int64:", "Int64 value",
(sender) => Task.FromResult <long?>(this.l),
(sender, value) => { this.l = value; return(Task.CompletedTask); }),
new StringControlParameter("String", "Page1", "String:", "String value",
(sender) => Task.FromResult <string>(this.s),
(sender, value) => { this.s = value; return(Task.CompletedTask); }),
new TimeControlParameter("Time", "Page1", "Time:", "Time value",
(sender) => Task.FromResult <TimeSpan?>(this.t),
(sender, value) => { this.t = value; return(Task.CompletedTask); }));
}
public override void ConnectClients()
{
base.ConnectClients();
Assert.AreEqual(XmppState.Connected, this.client1.State);
Assert.AreEqual(XmppState.Connected, this.client2.State);
this.controlClient = new ControlClient(this.client1);
this.controlServer = new ControlServer(this.client2,
new BooleanControlParameter("Bool", "Page1", "Bool:", "Boolean value", (sender) => this.b, (sender, value) => this.b = value),
new ColorControlParameter("Color", "Page1", "Color:", "Color value", (sender) => this.cl, (sender, value) => this.cl = value),
new DateControlParameter("Date", "Page1", "Date:", "Date value", DateTime.MinValue, DateTime.MaxValue, (sender) => this.d, (sender, value) => this.d = value),
new DateTimeControlParameter("DateTime", "Page1", "DateTime:", "DateTime value", DateTime.MinValue, DateTime.MaxValue, (sender) => this.dt, (sender, value) => this.dt = value),
new DoubleControlParameter("Double", "Page1", "Double:", "Double value", (sender) => this.db, (sender, value) => this.db = value),
new DurationControlParameter("Duration", "Page1", "Duration:", "Duration value", (sender) => this.dr, (sender, value) => this.dr = value),
new EnumControlParameter("Enum", "Page1", "Enum:", "Enum value", typeof(TypeCode), (sender) => this.e, (sender, value) => this.e = (TypeCode)value),
new Int32ControlParameter("Int32", "Page1", "Int32:", "Int32 value", (sender) => this.i, (sender, value) => this.i = value),
new Int64ControlParameter("Int64", "Page1", "Int64:", "Int64 value", (sender) => this.l, (sender, value) => this.l = value),
new StringControlParameter("String", "Page1", "String:", "String value", (sender) => this.s, (sender, value) => this.s = value),
new TimeControlParameter("Time", "Page1", "Time:", "Time value", (sender) => this.t, (sender, value) => this.t = value));
}
public static Workspace GetTemporaryWorkspace()
{
Workspace workspace = null;
if (!string.IsNullOrEmpty(temporaryWorkspaceName))
{
workspace = ControlServer.GetWorkspace(temporaryWorkspaceName, ControlServer.AuthenticatedUser);
}
if (string.IsNullOrEmpty(temporaryWorkspaceName))
{
temporaryWorkspaceName = string.Format("tfsman_{0}", DateTime.Now.Ticks);
}
if (workspace == null)
{
workspace = ControlServer.CreateWorkspace(temporaryWorkspaceName, ControlServer.AuthenticatedUser);
}
return(workspace);
}
public static void Run()
{
// initialize the serial port for COM1 (using D0 & D1)
// initialize the serial port for COM3 (using D7 & D8)
var serialPort = new SerialPort(SerialPorts.COM3, 57600, Parity.None, 8, StopBits.One);
serialPort.Open();
var server = new ControlServer(serialPort);
var led = new Microsoft.SPOT.Hardware.OutputPort(Pins.ONBOARD_LED, false);
var lv = false;
var a0 = new AnalogInput(AnalogChannels.ANALOG_PIN_A0, -1);
var a1 = new AnalogInput(AnalogChannels.ANALOG_PIN_A1, -1);
var uptimeVar = server.RegisterVariable("Uptime (s)", 0);
server.RegisterVariable("Speed", 0, v => { });
server.RegisterVariable("Turn", 0, v => { });
var a0Var = server.RegisterVariable("Analog 0", 0);
var a1Var = server.RegisterVariable("Analog 1", 0);
var magicCmd = server.RegisterCommand("Magic", () => {
Debug.Print("MAAAGIIICC");
return(42);
});
for (var i = 0; true; i++)
{
uptimeVar.Value = i;
a0Var.Value = a0.Read();
a1Var.Value = a1.Read();
led.Write(lv);
lv = !lv;
Thread.Sleep(1000);
}
}
private void SetupControlServer()
{
List<ControlParameter> Parameters = new List<ControlParameter>();
foreach (KeyValuePair<GpioPin, KeyValuePair<TextBlock, TextBlock>> Pin in gpioPins.Values)
{
string s = Pin.Key.PinNumber.ToString();
Parameters.Add(new BooleanControlParameter("GPIO" + s, "GPIO", "GPIO " + s + ".", "If the GPIO output should be high (checked) or low (unchecked).",
(Node) => Pin.Key.Read() == GpioPinValue.High,
(Node, Value) =>
{
Pin.Key.Write(Value ? GpioPinValue.High : GpioPinValue.Low);
Log.Informational("GPIO " + s + " turned " + (Value ? "HIGH" : "LOW"));
}));
List<string> Options = new List<string>();
foreach (GpioPinDriveMode Option in Enum.GetValues(typeof(GpioPinDriveMode)))
{
if (Pin.Key.IsDriveModeSupported(Option))
Options.Add(Option.ToString());
}
if (Options.Count > 0)
{
Parameters.Add(new StringControlParameter("GPIO" + s + "Mode", "GPIO Mode", "GPIO " + s + " Drive Mode:",
"The drive mode of the underlying hardware for the corresponding GPIO pin.", Options.ToArray(),
(Node) => Pin.Key.GetDriveMode().ToString(),
(Node, Value) =>
{
GpioPinDriveMode Mode = (GpioPinDriveMode)Enum.Parse(typeof(GpioPinDriveMode), Value);
Pin.Key.SetDriveMode(Mode);
Log.Informational("GPIO " + s + " drive mode set to " + Value);
}));
}
}
if (arduinoPins != null)
{
KeyValuePair<string, KeyValuePair<TextBlock, TextBlock>>[] ArduinoPins;
lock (arduinoPins)
{
ArduinoPins = new KeyValuePair<string, KeyValuePair<TextBlock, TextBlock>>[arduinoPins.Count];
arduinoPins.CopyTo(ArduinoPins, 0);
}
foreach (KeyValuePair<string, KeyValuePair<TextBlock, TextBlock>> Pin in ArduinoPins)
{
List<string> Options = new List<string>();
byte Capabilities;
if (Pin.Key.StartsWith("D"))
{
Parameters.Add(new BooleanControlParameter(Pin.Key, "Arduino D/O", "Arduino Digital Output on " + Pin.Key.ToString() + ".",
"If the Arduino digitial output should be high (checked) or low (unchecked).",
(Node) => arduino.digitalRead(byte.Parse(Pin.Key.Substring(1))) == PinState.HIGH,
(Node, Value) =>
{
arduino.digitalWrite(byte.Parse(Pin.Key.Substring(1)), Value ? PinState.HIGH : PinState.LOW);
Log.Informational("Arduino " + Pin.Key + " turned " + (Value ? "HIGH" : "LOW"));
}));
Capabilities = arduino.DeviceHardwareProfile.getPinCapabilitiesBitmask(byte.Parse(Pin.Key.Substring(1)));
}
else
{
Capabilities = arduino.DeviceHardwareProfile.getPinCapabilitiesBitmask((uint)(byte.Parse(Pin.Key.Substring(1)) +
arduino.DeviceHardwareProfile.AnalogOffset));
}
if ((Capabilities & (byte)PinCapability.ANALOG) != 0)
Options.Add("ANALOG");
if ((Capabilities & (byte)PinCapability.I2C) != 0)
Options.Add("I2C");
if ((Capabilities & (byte)PinCapability.INPUT) != 0)
Options.Add("INPUT");
if ((Capabilities & (byte)PinCapability.INPUT_PULLUP) != 0)
Options.Add("PULLUP");
if ((Capabilities & (byte)PinCapability.OUTPUT) != 0)
Options.Add("OUTPUT");
if ((Capabilities & (byte)PinCapability.PWM) != 0)
Options.Add("PWM");
if ((Capabilities & (byte)PinCapability.SERVO) != 0)
Options.Add("SERVO");
if (Options.Count > 0)
{
Parameters.Add(new StringControlParameter(Pin.Key + "Mode", "Arduino Mode", "Pin " + Pin.Key + " Drive Mode:",
"The drive mode of the underlying hardware for the corresponding Arduino pin.", Options.ToArray(),
(Node) => Pin.Key.StartsWith("D") ? arduino.getPinMode(byte.Parse(Pin.Key.Substring(1))).ToString() : arduino.getPinMode(Pin.Key).ToString(),
(Node, Value) =>
{
PinMode Mode = (PinMode)Enum.Parse(typeof(PinMode), Value);
if (Pin.Key.StartsWith("D"))
arduino.pinMode(byte.Parse(Pin.Key.Substring(1)), Mode);
else
arduino.pinMode(Pin.Key, Mode);
Log.Informational("Arduino " + Pin.Key + " drive mode set to " + Value);
}));
}
}
}
this.controlServer = new ControlServer(this.xmppClient, Parameters.ToArray());
this.bobClient = new BobClient(this.xmppClient, Path.Combine(Path.GetTempPath(), "BitsOfBinary"));
this.chatServer = new ChatServer(this.xmppClient, this.bobClient, this.sensorServer, this.controlServer);
}
/// <summary>
/// Invoked when application execution is being suspended. Application state is saved
/// without knowing whether the application will be terminated or resumed with the contents
/// of memory still intact.
/// </summary>
/// <param name="sender">The source of the suspend request.</param>
/// <param name="e">Details about the suspend request.</param>
private void OnSuspending(object sender, SuspendingEventArgs e)
{
var deferral = e.SuspendingOperation.GetDeferral();
if (arduino != null)
{
arduino.digitalWrite(13, PinState.LOW);
arduino.pinMode(13, PinMode.INPUT); // Onboard LED.
arduino.Dispose();
arduino = null;
}
if (arduinoUsb != null)
{
arduinoUsb.end();
arduinoUsb.Dispose();
arduinoUsb = null;
}
if (gpioPins != null)
{
foreach (KeyValuePair<GpioPin, KeyValuePair<TextBlock, TextBlock>> Pin in gpioPins.Values)
Pin.Key.Dispose();
gpioPins = null;
}
if (this.sampleTimer != null)
{
this.sampleTimer.Dispose();
this.sampleTimer = null;
}
if (this.chatServer != null)
{
this.chatServer.Dispose();
this.chatServer = null;
}
if (this.bobClient != null)
{
this.bobClient.Dispose();
this.bobClient = null;
}
if (this.controlServer != null)
{
this.controlServer.Dispose();
this.controlServer = null;
}
if (this.sensorServer != null)
{
this.sensorServer.Dispose();
this.sensorServer = null;
}
if (this.provisioningClient != null)
{
this.provisioningClient.Dispose();
this.provisioningClient = null;
}
if (this.thingRegistryClient != null)
{
this.thingRegistryClient.Dispose();
this.thingRegistryClient = null;
}
if (this.xmppClient != null)
{
this.xmppClient.Dispose();
this.xmppClient = null;
}
Log.Terminate();
deferral.Complete();
}
private void AttachFeatures()
{
this.controlServer = new ControlServer(this.xmppClient,
new BooleanControlParameter("Output", "Actuator", "Output:", "Digital output.",
(Node) => this.output,
async(Node, Value) =>
{
try
{
await this.SetOutput(Value, "XMPP");
}
catch (Exception ex)
{
Log.Critical(ex);
}
}));
this.sensorServer = new SensorServer(this.xmppClient, true);
this.sensorServer.OnExecuteReadoutRequest += (sender, e) =>
{
try
{
Log.Informational("Performing readout.", this.xmppClient.BareJID, e.Actor);
List <Field> Fields = new List <Field>();
DateTime Now = DateTime.Now;
if (e.IsIncluded(FieldType.Identity))
{
Fields.Add(new StringField(ThingReference.Empty, Now, "Device ID", this.deviceId, FieldType.Identity, FieldQoS.AutomaticReadout));
}
if (this.output.HasValue)
{
Fields.Add(new BooleanField(ThingReference.Empty, Now, "Output", this.output.Value,
FieldType.Momentary, FieldQoS.AutomaticReadout, true));
}
e.ReportFields(true, Fields);
}
catch (Exception ex)
{
Log.Critical(ex);
}
};
this.xmppClient.OnError += (Sender, ex) => Log.Error(ex);
this.xmppClient.OnPasswordChanged += (Sender, e) => Log.Informational("Password changed.", this.xmppClient.BareJID);
this.xmppClient.OnPresenceSubscribe += (Sender, e) =>
{
Log.Informational("Accepting friendship request.", this.xmppClient.BareJID, e.From);
e.Accept();
};
this.xmppClient.OnPresenceUnsubscribe += (Sender, e) =>
{
Log.Informational("Friendship removed.", this.xmppClient.BareJID, e.From);
e.Accept();
};
this.xmppClient.OnPresenceSubscribed += (Sender, e) => Log.Informational("Friendship request accepted.", this.xmppClient.BareJID, e.From);
this.xmppClient.OnPresenceUnsubscribed += (Sender, e) => Log.Informational("Friendship removal accepted.", this.xmppClient.BareJID, e.From);
this.bobClient = new BobClient(this.xmppClient, Path.Combine(Path.GetTempPath(), "BitsOfBinary"));
this.chatServer = new ChatServer(this.xmppClient, this.bobClient, this.sensorServer, this.controlServer);
// XEP-0054: vcard-temp: http://xmpp.org/extensions/xep-0054.html
this.xmppClient.RegisterIqGetHandler("vCard", "vcard-temp", this.QueryVCardHandler, true);
}
static void Main(string[] args)
{
try
{
Console.ForegroundColor = ConsoleColor.White;
Console.Out.WriteLine("Welcome to the Mock Temperature sensor application.");
Console.Out.WriteLine(new string('-', 79));
Console.Out.WriteLine("This application will simulate an outside temperature sensor.");
Console.Out.WriteLine("Values will be published over XMPP using the interface defined in the IEEE XMPP IoT extensions.");
Console.Out.WriteLine("You can also chat with the sensor.");
Log.Register(new ConsoleEventSink());
Log.RegisterExceptionToUnnest(typeof(System.Runtime.InteropServices.ExternalException));
Log.RegisterExceptionToUnnest(typeof(System.Security.Authentication.AuthenticationException));
credentials = SimpleXmppConfiguration.GetConfigUsingSimpleConsoleDialog("xmpp.config",
Guid.NewGuid().ToString().Replace("-", string.Empty), // Default user name.
Guid.NewGuid().ToString().Replace("-", string.Empty), // Default password.
typeof(Program).Assembly);
using (XmppClient Client = new XmppClient(credentials, "en", typeof(Program).Assembly))
{
if (credentials.Sniffer)
{
Client.Add(new ConsoleOutSniffer(BinaryPresentationMethod.ByteCount, LineEnding.PadWithSpaces));
}
if (!string.IsNullOrEmpty(credentials.Events))
{
Log.Register(new XmppEventSink("XMPP Event Sink", Client, credentials.Events, false));
}
if (!string.IsNullOrEmpty(credentials.ThingRegistry))
{
thingRegistryClient = new ThingRegistryClient(Client, credentials.ThingRegistry);
thingRegistryClient.Claimed += (sender, e) =>
{
ownerJid = e.JID;
Log.Informational("Thing has been claimed.", ownerJid, new KeyValuePair <string, object>("Public", e.IsPublic));
};
thingRegistryClient.Disowned += (sender, e) =>
{
Log.Informational("Thing has been disowned.", ownerJid);
ownerJid = string.Empty;
Register();
};
thingRegistryClient.Removed += (sender, e) =>
{
Log.Informational("Thing has been removed from the public registry.", ownerJid);
};
}
ProvisioningClient ProvisioningClient = null;
if (!string.IsNullOrEmpty(credentials.Provisioning))
{
ProvisioningClient = new ProvisioningClient(Client, credentials.Provisioning);
}
Timer ConnectionTimer = new Timer((P) =>
{
if (Client.State == XmppState.Offline || Client.State == XmppState.Error || Client.State == XmppState.Authenticating)
{
try
{
Client.Reconnect();
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
}, null, 60000, 60000);
bool Connected = false;
bool ImmediateReconnect;
Client.OnStateChanged += (sender, NewState) =>
{
switch (NewState)
{
case XmppState.Connected:
Connected = true;
if (!registered && thingRegistryClient != null)
{
Register();
}
break;
case XmppState.Offline:
ImmediateReconnect = Connected;
Connected = false;
if (ImmediateReconnect)
{
Client.Reconnect();
}
break;
}
};
Client.OnPresenceSubscribe += (sender, e) =>
{
e.Accept(); // TODO: Provisioning
RosterItem Item = Client.GetRosterItem(e.FromBareJID);
if (Item is null || Item.State == SubscriptionState.None || Item.State == SubscriptionState.From)
{
Client.RequestPresenceSubscription(e.FromBareJID);
}
Client.SetPresence(Availability.Chat);
};
Client.OnPresenceUnsubscribe += (sender, e) =>
{
e.Accept();
};
Client.OnRosterItemUpdated += (sender, e) =>
{
if (e.State == SubscriptionState.None && e.PendingSubscription != PendingSubscription.Subscribe)
{
Client.RemoveRosterItem(e.BareJid);
}
};
bool SwitchOn = false;
SensorServer SensorServer = new SensorServer(Client, ProvisioningClient, false);
SensorServer.OnExecuteReadoutRequest += (Sender, Request) =>
{
DateTime Now = DateTime.Now;
Log.Informational("Readout requested", string.Empty, Request.Actor);
Request.ReportFields(true, new BooleanField(ThingReference.Empty, Now, "Lamp", SwitchOn, FieldType.Momentary, FieldQoS.AutomaticReadout));
};
ControlServer ControlServer = new ControlServer(Client,
new BooleanControlParameter("Lamp", "Control", "Lamp switch on.", "If checked, lamp is turned on.",
(Node) => SwitchOn,
(Node, Value) =>
{
SwitchOn = Value;
Log.Informational(Environment.NewLine + Environment.NewLine + "Lamp turned " + (SwitchOn ? "ON" : "OFF") + Environment.NewLine + Environment.NewLine);
}));
BobClient BobClient = new BobClient(Client, Path.Combine(Path.GetTempPath(), "BitsOfBinary"));
ChatServer ChatServer = new ChatServer(Client, BobClient, SensorServer, ControlServer, ProvisioningClient);
InteroperabilityServer InteroperabilityServer = new InteroperabilityServer(Client);
InteroperabilityServer.OnGetInterfaces += (sender, e) =>
{
e.Add("XMPP.IoT.Actuator.Lamp");
};
Client.Connect();
while (true)
{
Thread.Sleep(1000);
}
}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Out.WriteLine(ex.Message);
}
finally
{
Log.Terminate();
}
}
private async void StartActuator()
{
try
{
Log.Informational("Starting application.");
SimpleXmppConfiguration xmppConfiguration = SimpleXmppConfiguration.GetConfigUsingSimpleConsoleDialog("xmpp.config",
Guid.NewGuid().ToString().Replace("-", string.Empty), // Default user name.
Guid.NewGuid().ToString().Replace("-", string.Empty), // Default password.
FormSignatureKey, FormSignatureSecret, typeof(App).GetTypeInfo().Assembly);
Log.Informational("Connecting to XMPP server.");
xmppClient = xmppConfiguration.GetClient("en", typeof(App).GetTypeInfo().Assembly, false);
xmppClient.AllowRegistration(FormSignatureKey, FormSignatureSecret);
if (xmppConfiguration.Sniffer && MainPage.Sniffer != null)
{
xmppClient.Add(MainPage.Sniffer);
}
if (!string.IsNullOrEmpty(xmppConfiguration.Events))
{
Log.Register(new XmppEventSink("XMPP Event Sink", xmppClient, xmppConfiguration.Events, false));
}
if (!string.IsNullOrEmpty(xmppConfiguration.ThingRegistry))
{
thingRegistryClient = new ThingRegistryClient(xmppClient, xmppConfiguration.ThingRegistry);
thingRegistryClient.Claimed += (sender, e) =>
{
ownerJid = e.JID;
Log.Informational("Thing has been claimed.", ownerJid, new KeyValuePair <string, object>("Public", e.IsPublic));
this.RaiseOwnershipChanged();
};
thingRegistryClient.Disowned += (sender, e) =>
{
Log.Informational("Thing has been disowned.", ownerJid);
ownerJid = string.Empty;
this.Register(); // Will call this.OwnershipChanged() after successful registration.
};
thingRegistryClient.Removed += (sender, e) =>
{
Log.Informational("Thing has been removed from the public registry.", ownerJid);
};
}
if (!string.IsNullOrEmpty(xmppConfiguration.Provisioning))
{
provisioningClient = new ProvisioningClient(xmppClient, xmppConfiguration.Provisioning);
}
Timer ConnectionTimer = new Timer((P) =>
{
if (xmppClient.State == XmppState.Offline || xmppClient.State == XmppState.Error || xmppClient.State == XmppState.Authenticating)
{
try
{
Log.Informational("Reconnecting.");
xmppClient.Reconnect();
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
}, null, 60000, 60000);
xmppClient.OnStateChanged += (sender, NewState) =>
{
Log.Informational(NewState.ToString());
switch (NewState)
{
case XmppState.Connected:
connected = true;
if (!registered && thingRegistryClient != null)
{
Register();
}
break;
case XmppState.Offline:
immediateReconnect = connected;
connected = false;
if (immediateReconnect)
{
xmppClient.Reconnect();
}
break;
}
};
xmppClient.OnPresenceSubscribe += (sender, e) =>
{
Log.Informational("Subscription request received from " + e.From + ".");
e.Accept(); // TODO: Provisioning
RosterItem Item = xmppClient.GetRosterItem(e.FromBareJID);
if (Item == null || Item.State == SubscriptionState.None || Item.State == SubscriptionState.From)
{
xmppClient.RequestPresenceSubscription(e.FromBareJID);
}
xmppClient.SetPresence(Availability.Chat);
};
xmppClient.OnPresenceUnsubscribe += (sender, e) =>
{
Log.Informational("Unsubscription request received from " + e.From + ".");
e.Accept();
};
xmppClient.OnRosterItemUpdated += (sender, e) =>
{
if (e.State == SubscriptionState.None && e.PendingSubscription != PendingSubscription.Subscribe)
{
xmppClient.RemoveRosterItem(e.BareJid);
}
};
bool SwitchOn = false;
sensorServer = new SensorServer(xmppClient, provisioningClient, false);
sensorServer.OnExecuteReadoutRequest += (Sender, Request) =>
{
DateTime Now = DateTime.Now;
Log.Informational("Readout requested", string.Empty, Request.Actor);
Request.ReportFields(true, new BooleanField(ThingReference.Empty, Now, "Lamp", SwitchOn, FieldType.Momentary, FieldQoS.AutomaticReadout));
};
controlServer = new ControlServer(xmppClient,
new BooleanControlParameter("Lamp", "Control", "Lamp switch on.", "If checked, lamp is turned on.",
(Node) => SwitchOn,
(Node, Value) =>
{
SwitchOn = Value;
Log.Informational("Lamp turned " + (SwitchOn ? "ON" : "OFF"));
UpdateMainWindow(SwitchOn);
}));
this.bobClient = new BobClient(this.xmppClient, Path.Combine(Path.GetTempPath(), "BitsOfBinary"));
this.chatServer = new ChatServer(xmppClient, this.bobClient, this.sensorServer, this.controlServer);
interoperabilityServer = new InteroperabilityServer(xmppClient);
interoperabilityServer.OnGetInterfaces += (sender, e) =>
{
e.Add("XMPP.IoT.Actuator.Lamp");
};
xmppClient.Connect();
}
catch (Exception ex)
{
Log.Emergency(ex);
MessageDialog Dialog = new MessageDialog(ex.Message, "Error");
await Dialog.ShowAsync();
}
}
/// <summary>
/// Invoked when application execution is being suspended. Application state is saved
/// without knowing whether the application will be terminated or resumed with the contents
/// of memory still intact.
/// </summary>
/// <param name="sender">The source of the suspend request.</param>
/// <param name="e">Details about the suspend request.</param>
private void OnSuspending(object sender, SuspendingEventArgs e)
{
var deferral = e.SuspendingOperation.GetDeferral();
if (this.sampleTimer != null)
{
this.sampleTimer.Dispose();
this.sampleTimer = null;
}
if (this.interoperabilityServer != null)
{
this.interoperabilityServer.Dispose();
this.interoperabilityServer = null;
}
if (this.chatServer != null)
{
this.chatServer.Dispose();
this.chatServer = null;
}
if (this.bobClient != null)
{
this.bobClient.Dispose();
this.bobClient = null;
}
if (this.controlServer != null)
{
this.controlServer.Dispose();
this.controlServer = null;
}
if (this.sensorServer != null)
{
this.sensorServer.Dispose();
this.sensorServer = null;
}
if (this.provisioningClient != null)
{
this.provisioningClient.Dispose();
this.provisioningClient = null;
}
if (this.thingRegistryClient != null)
{
this.thingRegistryClient.Dispose();
this.thingRegistryClient = null;
}
if (this.xmppClient != null)
{
this.xmppClient.Dispose();
this.xmppClient = null;
}
Log.Terminate();
deferral.Complete();
}
