/// <summary>
/// Send a message.
/// </summary>
/// <param name="controller">Concerned controller.</param>
/// <param name="message">Message to send.</param>
internal static bool Send(ControllerDto controller, MessageToDto message)
{
// get serial message
MessageDto serialMessage;
using (var ctx = new MessageProcessDtoFactory())
{
serialMessage = ctx.Convert(message);
}
// wait for sending turn & request process
Queue.WaitMessageSending.WaitOne(DeviceConstants.WaitEventTimeout);
Queue.WaitMessageReception.WaitOne(DeviceConstants.WaitEventTimeout);
// set processed message
Queue.MessageTo = message;
// send message
var result = PortBusiness.Send(Queue.Controller.Port, serialMessage);
Queue.WaitMessageReception.Set();
// wait round time trip
Thread.Sleep(MessageConstants.WaitForRoundTimeTrip);
return result;
}
/// <summary>
/// Get the value of the device.
/// </summary>
/// <param name="controller">Concerned controller.</param>
/// <param name="device">Concerned device.</param>
/// <returns>True if device value is completed.</returns>
public bool Get(ControllerDto controller, DeviceDto device)
{
// send message
if (MessageProcessBusiness.Send(controller, CreateCommandMessage(controller, device.ZIdentifier)))
{
// wait for ack and response
WaitAcknowledgment.WaitOne(DeviceConstants.WaitEventTimeout);
WaitEvent.WaitOne(DeviceConstants.WaitEventTimeout);
WaitReport.WaitOne(DeviceConstants.WaitEventTimeout);
}
return !string.IsNullOrEmpty(device.ConstructorIdentifier) && !string.IsNullOrEmpty(device.ProductIdentifier);
}
/// <summary>
/// Get switch value.
/// </summary>
/// <param name="controller">Concerned controller.</param>
/// <param name="node">Concerned node.</param>
/// <returns>Value of node.</returns>
public bool Get(ControllerDto controller, DeviceDto node)
{
// send message
node.Value = null;
if (MessageProcessBusiness.Send(controller, CreateCommandMessage(node, new List<byte> {(byte) SwitchBinaryAction.Get})))
{
// wait for response from controller
WaitAcknowledgment.WaitOne(DeviceConstants.WaitEventTimeout);
WaitResponseEvent.WaitOne(DeviceConstants.WaitEventTimeout);
WaitReportEvent.WaitOne(DeviceConstants.WaitEventTimeout);
}
return node.Value != null;
}
/// <summary>
/// Get the current value of a node.
/// </summary>
/// <param name="controller">Controller to use.</param>
/// <param name="node">Node to call.</param>
/// <returns>Node value.</returns>
internal static bool Get(ControllerDto controller, DeviceDto node)
{
var result = false;
if (node.DeviceClassGeneric != DeviceClassGeneric.Other)
{
var processAttr = ReflectionHelper.GetEnumValueAttribute<DeviceClassGeneric, DataReceivedAttribute>(node.DeviceClassGeneric);
if (processAttr != null)
{
var iDevice = ReflectionHelper.CreateInstance<IDevice>(processAttr.ClassType);
if(iDevice != null) result = iDevice.Get(controller, node);
}
}
return result;
}
/// <summary>
/// Connect to a port.
/// </summary>
/// <param name="controller">Controller to connect.</param>
/// <returns>Connected controller.</returns>
internal static ControllerDto Connect(ControllerDto controller)
{
// close existing port
Close(controller.Port);
// connect port
controller.Port = PortBusiness.Connect(controller.Port);
// initialize queue
Queue = new MessageProcessDto { Controller = controller };
// start listener
if (Queue.TaskReceive == null)
{
Queue.TaskContinue = true;
Queue.TaskReceive = new Task(() => ReceiveTask(Queue));
Queue.TaskReceive.Start();
}
return controller;
}
/// <summary>
/// Get node protocol.
/// </summary>
/// <param name="controller">Controller.</param>
/// <param name="node">Z node to complete.</param>
/// <returns>Process result.</returns>
private static bool GetNodeProtocol(ControllerDto controller, DeviceDto node)
{
// send message
if (MessageProcessBusiness.Send(controller, CreateCommandMessage(MessageCommand.GetNodeProtocol, controller, node.ZIdentifier)))
{
// wait for response
WaitAcknowledgment.WaitOne(DeviceConstants.WaitEventTimeout);
WaitEvent.WaitOne(DeviceConstants.WaitEventTimeout);
}
// get result
node.HomeIdentifier = controller.HomeIdentifier;
return node.DeviceClass != DeviceClass.Unknown && node.DeviceClassGeneric != DeviceClassGeneric.Other;
}
/// <summary>
/// Execute command "Get home id" and node identifier.
/// </summary>
/// <param name="controller">Concerned controller.s</param>
/// <param name="receivedMessage">Message received.</param>
private static void GetHomeIdResponse(ControllerDto controller, MessageFromDto receivedMessage)
{
// complete controller
if (receivedMessage.Content.Count >= 5)
{
controller.HomeIdentifier = BitConverter.ToString(receivedMessage.Content.Take(4).ToArray());
controller.ZIdentifier = receivedMessage.Content.Last();
}
// release event
WaitEvent.Set();
}
/// <summary>
/// Get API capabilities.
/// </summary>
/// <param name="controller">Concerned controller.</param>
/// <returns>True if identifier is got.</returns>
/// <remarks>Not used because I don't how to use the response.</remarks>
private static bool GetDeviceCapabilities(ControllerDto controller)
{
// send message
if (MessageProcessBusiness.Send(controller, CreateCommandMessage(MessageCommand.GetDeviceCapabilities, controller)))
{
// wait for ack and response
WaitAcknowledgment.WaitOne(DeviceConstants.WaitEventTimeout);
WaitEvent.WaitOne(DeviceConstants.WaitEventTimeout);
}
// get result
return !string.IsNullOrEmpty(controller.ConstructorIdentifier) &&
!string.IsNullOrEmpty(controller.ProductType) &&
!string.IsNullOrEmpty(controller.ProductIdentifier);
}
/// <summary>
/// Execute command to get note list.
/// </summary>
/// <param name="controller">Concerned controller.s</param>
/// <param name="receivedMessage">Message received.</param>
private static void GetControllerNodesResponse(ControllerDto controller, MessageFromDto receivedMessage)
{
if (receivedMessage.Content.Count >= 29)
{
controller.Nodes = new List<DeviceDto>();
for (var i = 3; i < 32; i++)
{
var byteData = receivedMessage.Content[i];
for (var b = 0; b < 8; b++)
{
if ((byteData & (byte) Math.Pow(2, b)) == (byte) Math.Pow(2, b))
{
int zId = ((i - 3)*8) + b + 1;
if (zId == controller.ZIdentifier)
{
controller.Nodes.Add(controller);
}
else
{
controller.Nodes.Add(new DeviceDto
{
HomeIdentifier = controller.HomeIdentifier,
ZIdentifier = zId
});
}
}
}
}
}
else
{
receivedMessage.Node = null;
}
// release event
WaitEvent.Set();
}
/// <summary>
/// Set ON a switch.
/// </summary>
/// <param name="controller">Concerned controller.</param>
/// <param name="node">Concerned node.</param>
/// <param name="value">"0xFF" to set on, "0x00" to set off.</param>
/// <returns>Updated node.</returns>
public bool Set(ControllerDto controller, DeviceDto node, List<byte> value)
{
var result = false;
// send message
if (MessageProcessBusiness.Send(controller, CreateCommandMessage(node, new List<byte> {(byte) SwitchBinaryAction.Set, value.FirstOrDefault()})))
{
// wait for response from controller
WaitAcknowledgment.WaitOne(DeviceConstants.WaitEventTimeout);
WaitResponseEvent.WaitOne(DeviceConstants.WaitEventTimeout);
result = Get(controller, node);
}
// get node value
return result && node.Value.SequenceEqual(value);
}
/// <summary>
/// Set the device value.
/// </summary>
/// <param name="controller">Concerned controller.</param>
/// <param name="device">Concerned device.</param>
/// <param name="value">Value to set. First byte is parameter identifier, next is parameter value.</param>
/// <returns>True if value is setted.</returns>
public bool Set(ControllerDto controller, DeviceDto device, List<byte> value)
{
return true;
}
/// <summary>
/// Execute command "Get version".
/// </summary>
/// <param name="controller">Concerned controller.s</param>
/// <param name="receivedMessage">Message received.</param>
private static void GetZVersionResponse(ControllerDto controller, MessageFromDto receivedMessage)
{
// complete controller
if (receivedMessage.Content.Count >= 3)
{
var end = receivedMessage.Content.TakeWhile(b => b != '\0').Count();
controller.ZVersion = Encoding.ASCII.GetString(receivedMessage.Content.Take(end).ToArray());
controller.DeviceClass = (DeviceClass)receivedMessage.Content[receivedMessage.Content.Count - 1];
}
// release event
WaitEvent.Set();
}
/// <summary>
/// Close controller.
/// </summary>
/// <param name="controller">Controller to close.</param>
internal static void Close(ControllerDto controller)
{
MessageProcessBusiness.Close(controller.Port);
controller.IsReady = false;
}
/// <summary>
/// Configure a device.
/// </summary>
/// <param name="controller">Controller to use.</param>
/// <param name="node">Node to configure.</param>
/// <param name="parameter">Parameter identifier.</param>
/// <param name="value">Parameter value.</param>
/// <returns>Configure result.</returns>
internal static bool Configure(ControllerDto controller, DeviceDto node, byte parameter, List<byte> value)
{
return ConfigurationBusiness.Set(controller, node, parameter, value);
}
/// <summary>
/// Close all devices.
/// </summary>
/// <param name="controller">Controller to close.</param>
internal static void Close(ControllerDto controller)
{
ControllerBusiness.Close(controller);
}
/// <summary>
/// Process the response to get a node protocol.
/// </summary>
/// <param name="controller">Concerned controller.s</param>
/// <param name="receivedMessage">Message received.</param>
private static void GetNodeProtocolResponse(ControllerDto controller, MessageFromDto receivedMessage)
{
if (receivedMessage.Content.Count >= 5)
{
var node = controller.Nodes.FirstOrDefault(x => x.ZIdentifier == receivedMessage.ZIdentifier);
if (node != null)
{
node.DeviceClass = (DeviceClass) receivedMessage.Content[3];
node.DeviceClassGeneric = (DeviceClassGeneric) receivedMessage.Content[4];
}
}
// release event
WaitEvent.Set();
}
/// <summary>
/// Get Z version.
/// </summary>
/// <param name="controller">Concerned controller.</param>
/// <returns>True if identifier is got.</returns>
private static bool GetZVersion(ControllerDto controller)
{
// send message
if (MessageProcessBusiness.Send(controller, CreateCommandMessage(MessageCommand.GetVersion, controller)))
{
// wait for ack and response
WaitAcknowledgment.WaitOne(DeviceConstants.WaitEventTimeout);
WaitEvent.WaitOne(DeviceConstants.WaitEventTimeout);
}
// get result
return !string.IsNullOrEmpty(controller.ZVersion);
}
/// <summary>
/// Initialize the controller on specified port.
/// </summary>
/// <param name="controller">Port to initialize.</param>
/// <returns>Controller of the port.</returns>
private static ControllerDto Connect(ControllerDto controller)
{
// open port
controller = MessageProcessBusiness.Connect(controller);
if (controller.Port.IsOpen)
{
controller.IsReady = GetHomeId(controller);
if (controller.IsReady) controller.IsReady = GetControllerNodes(controller);
if (controller.IsReady) controller.IsReady = GetDeviceCapabilities(controller);
if (controller.IsReady)
{
foreach (var x in controller.Nodes)
{
controller.IsReady = GetNodeProtocol(controller, x);
}
}
}
else
{
controller.IsReady = false;
}
return controller;
}
/// <summary>
/// Get the value of the device.
/// </summary>
/// <param name="controller">Concerned controller.</param>
/// <param name="device">Concerned device.</param>
/// <returns>True if device value is completed.</returns>
public bool Get(ControllerDto controller, DeviceDto device)
{
return false;
}
/// <summary>
/// Execute command to get COM capabilitis.
/// </summary>
/// <param name="controller">Concerned controller.s</param>
/// <param name="receivedMessage">Message received.</param>
private static void GetApiCapabilitiesResponse(ControllerDto controller, MessageFromDto receivedMessage)
{
if (receivedMessage.Content.Count >= 6)
{
decimal version;
decimal.TryParse(string.Concat(receivedMessage.Content[0], ",", receivedMessage.Content[1]), out version);
controller.ApiVersion = version;
controller.ConstructorIdentifier = string.Concat(receivedMessage.Content[2].ToString("00"), receivedMessage.Content[3].ToString("00"));
controller.ProductType = string.Concat(receivedMessage.Content[3].ToString("00"), receivedMessage.Content[4].ToString("00"));
controller.ProductIdentifier = string.Concat(receivedMessage.Content[5].ToString("00"), receivedMessage.Content[6].ToString("00"));
controller.ApiCapabilities = receivedMessage.Content.Skip(7).ToList();
}
// release event
WaitEvent.Set();
}
/// <summary>
/// Configure a parameter.
/// </summary>
/// <param name="controller">Controller used to send message.</param>
/// <param name="node">Concerned message.</param>
/// <param name="parameter">Parameter identifier.</param>
/// <param name="value">Parameter value.</param>
/// <returns>True if configuration is OK.</returns>
internal static bool Set(ControllerDto controller, DeviceDto node, byte parameter, List<byte> value)
{
var content = new List<byte> { (byte)ConfigurationAction.Set, parameter, (byte)value.Count };
content.AddRange(value);
// send message
if (MessageProcessBusiness.Send(controller, CreateCommandMessage(node, content)))
{
// wait for ack and response
WaitAcknowledgment.WaitOne(DeviceConstants.WaitEventTimeout);
WaitEvent.WaitOne(DeviceConstants.WaitEventTimeout);
}
return true;
}
/// <summary>
/// Get nodes known by the controller.
/// </summary>
/// <param name="controller">Controller.</param>
/// <returns>Process result.</returns>
private static bool GetControllerNodes(ControllerDto controller)
{
// send message
if (MessageProcessBusiness.Send(controller, CreateCommandMessage(MessageCommand.GetControllerNodes, controller)))
{
// wait for response
WaitAcknowledgment.WaitOne(DeviceConstants.WaitEventTimeout);
WaitEvent.WaitOne(DeviceConstants.WaitEventTimeout);
}
// get result
var result = controller.Nodes != null;
if (!result) controller.Nodes = new List<DeviceDto>();
return result;
}
