private bool PLCStatus(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCStatusData;
Logger.InfoFormat("Ricevuto Messaggio {1}:{2} da {0}", Message.SourceApplicationName, MsgData.PLCName, MsgData.Status, MsgData.validation);
RetValue = MsgData.validation;
if (MsgData.validation)
{
var plc = model.ListPLCItems.FirstOrDefault(item => item.Name == MsgData.PLCName);
if (plc != null)
{
plc.ConnectionStatus = MsgData.Status;
}
else
{
RetValue = false;
}
}
return(RetValue);
}
/// <summary>
/// Implementazione esecuzione comando di rimozione della sottoscrizione di una lista di plctags
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool RemovePLCTags(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagsData;
var tagslist = MsgData.Tags;
Logger.InfoFormat("{0}", Message.SourceApplicationName);
for (int i = 0; i < tagslist.Count; i++)
{
var tag = tagslist[i];
if (!RemovePLCTag(Message.SourceApplicationName, tag))
{
tag.Validation = false;
RetValue = false;
}
else
{
tag.Validation = true;
}
}
// invio messaggio di risposta generica
return(SendResponse(Message, MsgCodes.ResultRemovePLCTags, MsgData, RetValue));
}
private bool DisconnectSubscriber(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data (not useful for now)
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as MsgData;
Logger.InfoFormat("{1} da {0}", Message.SourceApplicationName, MsgData.MsgCode);
// gestione subscriptions
if (ListSubscriptions.ContainsKey(Message.SourceApplicationName))
{
foreach (var sub in ListSubscriptions[Message.SourceApplicationName].ToList())
{
RemoveProperty(Message.SourceApplicationName, new Property()
{
ObjPath = sub.ObjPath
});
}
ListSubscriptions.Remove(Message.SourceApplicationName);
}
else
{
// non esiste !
Logger.WarnFormat("{0} non sottoscritto!", Message.SourceApplicationName);
RetValue = false;
}
/* invio messaggio di risposta */
return(SendResponse(Message, MsgCodes.ResultDisconnectSubscriber, MsgData, RetValue));
}
private bool SubscribeProperty(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PropertyData;
var prop = MsgData.Prop;
Logger.InfoFormat("{1} da {0}", Message.SourceApplicationName, prop.ObjPath);
RetValue = SubscribeProperty(Message.SourceApplicationName, prop);
/* invio messaggio di risposta */
RetValue = SendResponse(Message, MsgCodes.ResultSubscribeProperty, MsgData, RetValue);
// all'atto della sottoscrizione invio valore attuale della property
if (RetValue)
{
PropertyNotifyToSubscriber(Message.SourceApplicationName, prop);
}
return(RetValue);
}
private bool PLCTagsChanged(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagsData;
var plctags = MsgData.Tags;
Logger.InfoFormat("Ricevuto Messaggio da {0}", Message.SourceApplicationName);
foreach (var plctag in plctags)
{
bool bOK = true;
// trova il tag corrispondente (uno solo) all'indirizzo sottoscritto
TagItem tag = ListTagItems.FirstOrDefault(item => item.PLCName == plctag.PLCName && item.Address == plctag.Address);
if (tag != null)
{
//
try
{
tag.Value = plctag.Value;
Logger.InfoFormat("Cambiato Tag {0} : {1}/{2}:{3} -> {4}", tag.Name, tag.PLCName, tag.Address, tag.Type, tag.Value);
}
catch (Exception exc)
{
Logger.WarnFormat("Errore in cambio Tag value {0} : {1}/{2}:{3} -> {4} {5}", tag.Name, tag.PLCName, tag.Address, tag.Type, tag.Value, exc.Message);
}
// recuperare la lista delle properties dell'impianto
List <MariniProperty> props = mariniImpiantoTree.MariniImpianto.GetObjectListByType(typeof(MariniProperty)).Cast <MariniProperty>().ToList();
// trova la property associata e cambia il valore
MariniProperty property = props.FirstOrDefault(prp => prp.bind == tag.Name);
if (property != null)
{
try
{
property.value = tag.Value;
}
catch (Exception exc)
{
Logger.WarnFormat("Errore in cambio valore property {0}:{1} {2}", property.name, tag.Value, exc.Message);
bOK = false;
}
}
}
else
{
Logger.InfoFormat("Tag associato a : {0}/{1} non trovato", plctag.PLCName, plctag.Address);
bOK = false;
}
if (bOK == false)
{
RetValue = bOK;
}
}
return(RetValue);
}
/// <summary>
/// Implementazione esecuzione comando di disconnessione di un client sottoscrittore
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool DisconnectSubscriber(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as MsgData;
Logger.InfoFormat("{1} da {0}", Message.SourceApplicationName, MsgData.MsgCode);
// gestione subscriptions
if (_Subs.ContainsKey(Message.SourceApplicationName))
{
foreach (var sub in _Subs[Message.SourceApplicationName].ToList())
{
RemovePLCTag(Message.SourceApplicationName, new PLCTag()
{
PLCName = sub.PLCName, Address = sub.TagAddress
});
}
_Subs.Remove(Message.SourceApplicationName);
}
else
{
// non esiste !
Logger.WarnFormat("{0} non sottoscritto!", Message.SourceApplicationName);
RetValue = false;
}
/* invio messaggio di risposta generica */
return(SendResponse(Message, MsgCodes.ResultDisconnectSubscriber, MsgData, RetValue));
}
private bool ResultDisconnectPLC(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCData;
Logger.InfoFormat("Ricevuto Messaggio {1} da {0}", Message.SourceApplicationName, MsgData.PLCName);
RetValue = MsgData.validation;
if (MsgData.validation)
{
var plc = model.ListPLCItems.FirstOrDefault(item => item.Name == MsgData.PLCName);
if (plc != null)
{
// reentrant... approfondire
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
{
model.ListPLCItems.Remove(plc);
}));
}
}
return(RetValue);
}
/// <summary>
/// Sends remote method invocation message to the remote application and gets result.
/// This simplifies remove method invocation like calling a method locally.
/// It throws Exception if any Exception occured on remote application's method.
/// </summary>
/// <param name="methodName">Method name to invoke</param>
/// <param name="args">Method parameters</param>
/// <returns>Return value of remote method</returns>
protected object InvokeRemoteMethodAndGetResult(string methodName, params object[] args)
{
//Create MDSRemoteInvokeMessage object that contains invocation informations
var invokeMessage = new MDSRemoteInvokeMessage {
ServiceClassName = _serviceClassName, MethodName = methodName, Parameters = args
};
//Create MDS message to transmit MDSRemoteInvokeMessage.
var outgoingMessage = _serviceConsumer.MdsClient.CreateMessage();
outgoingMessage.DestinationServerName = RemoteApplication.ServerName;
outgoingMessage.DestinationApplicationName = RemoteApplication.ApplicationName;
outgoingMessage.DestinationCommunicatorId = RemoteApplication.CommunicatorId;
outgoingMessage.TransmitRule = MessageTransmitRules.DirectlySend;
outgoingMessage.MessageData = GeneralHelper.SerializeObject(invokeMessage);
//Send message and get response
var incomingMessage = outgoingMessage.SendAndGetResponse(Timeout);
incomingMessage.Acknowledge();
//Deserialize and check return value
var invokeReturnMessage = (MDSRemoteInvokeReturnMessage)GeneralHelper.DeserializeObject(incomingMessage.MessageData);
if (invokeReturnMessage.RemoteException != null)
{
throw invokeReturnMessage.RemoteException;
}
//Success
return(invokeReturnMessage.ReturnValue);
}
private bool PLCTagChanged(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagData;
Logger.InfoFormat("Ricevuto Messaggio {1}/{2}:{3} da {0}", Message.SourceApplicationName, MsgData.Tag.PLCName, MsgData.Tag.Address, MsgData.Tag.Value);
var tag = model.ListTagItems.FirstOrDefault(item => item.Address == MsgData.Tag.Address);
if (tag != null)
{
// funzionano entrambe, la Invoke esegue in modo bloccante, la BeginInvoke esegue in parallelo
//Application.Current.Dispatcher.Invoke(new Action(() =>
//{
// tag.Value = MsgData.Tag.Value.ToString();
//}));
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() =>
{
tag.Value = MsgData.Tag.Value.ToString();
}));
}
else
{
Logger.InfoFormat("Tag {0}/{1} non trovato", tag.PLCName, tag.Address);
RetValue = false;
}
return(RetValue);
}
private bool ResultSubscribePLCTag(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagData;
Logger.InfoFormat("Ricevuto Messaggio {1}/{2}:{3} da {0}", Message.SourceApplicationName, MsgData.Tag.PLCName, MsgData.Tag.Address, MsgData.Tag.Value);
TagItem tag = new TagItem()
{
PLCName = MsgData.Tag.PLCName, Address = MsgData.Tag.Address
};
if (tag != null)
{
Logger.InfoFormat("Aggiunto {0}/{1}", tag.PLCName, tag.Address);
if (GuiContext != null)
{
GuiContext.Send((o) => { model.ListTagItems.Add(tag); }, null);
}
else
{
Logger.InfoFormat("GuiContext NULL");
Debug.Assert(false);
}
}
return(RetValue);
}
/// <summary>
/// Implementazione esecuzione comando di richiesta lista plctags sotoscritti
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool GetSubscribedPLCTags(IIncomingMessage Message)
{
bool RetValue = true;
var tagslist = new List <PLCTag>();
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as MsgData;
Logger.InfoFormat("{0}", Message.SourceApplicationName);
// gestione subscriptions
if (!_Subs.ContainsKey(Message.SourceApplicationName))
{
Logger.WarnFormat("[{0}] has no subscriptions", Message.SourceApplicationName);
RetValue = false;
}
else
{
// costruisco la lista da inviare come risposta
foreach (var sub in _Subs[Message.SourceApplicationName].ToList())
{
var tag = new PLCTag()
{
PLCName = sub.PLCName, Address = sub.TagAddress, Validation = true
};
tagslist.Add(tag);
}
}
// invio messaggio di risposta generica
return(SendResponse(Message, MsgCodes.SubscribedPLCTags, new PLCTagsData()
{
MsgCode = MsgCodes.SubscribedPLCTags, Tags = tagslist
}, RetValue));
}
/// <summary>
/// This method handles received messages from other applications via DotNetMQ.
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Message parameters</param>
private void hmi_MessageReceived(object sender, MessageReceivedEventArgs e)
{
// Get message
var Message = e.Message;
try
{
// Get message data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as MsgData;
switch (MsgData.MsgCode)
{
case MsgCodes.PropertiesChanged: /* gestione da fare */ break;
case MsgCodes.PropertyChanged: PropertyChanged(Message); break;
case MsgCodes.SubscribedProperties: /* Da implementare */ break;
case MsgCodes.ResultSubscribeProperty: /* Da implementare */ break;
case MsgCodes.ResultSubscribeProperties: /* Da implementare */ break;
case MsgCodes.ResultRemoveProperty: /* Da implementare */ break;
case MsgCodes.ResultRemoveProperties: /* Da implementare */ break;
}
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
}
// Acknowledge that message is properly handled and processed. So, it will be deleted from queue.
e.Message.Acknowledge();
}
private bool RemoveProperties(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PropertiesData;
var props = MsgData.Props;
Logger.InfoFormat("{0}", Message.SourceApplicationName);
for (int i = 0; i < props.Count(); i++)
{
var prop = props[i];
if (!RemoveProperty(Message.SourceApplicationName, prop))
{
RetValue = false;
prop.Validation = false;
}
else
{
prop.Validation = true;
}
}
/* invio messaggio di risposta */
return(SendResponse(Message, MsgCodes.ResultRemoveProperties, MsgData, RetValue));
}
void client_MessageReceived(object sender, MDS.Client.MessageReceivedEventArgs e)
{
var instance = GeneralHelper.DeserializeObject(e.Message.MessageData);
IMessage message = new DotNetMQ(e.Message);
var eventArgs = new MessageReceivedEventArgs(this, message);
OnReceived(this, eventArgs);
}
static void MDSClient_MessageReceived(object sender, MessageReceivedEventArgs e)
{
//Get message
var stockQueryMessage = GeneralHelper.DeserializeObject(e.Message.MessageData) as StockQueryMessage;
if (stockQueryMessage == null)
{
return;
}
//Write message content
Console.WriteLine("Stock Query Message for: " + stockQueryMessage.StockCode);
//Get stock counts from a database...
int reservedStockCount;
int totalStockCount;
switch (stockQueryMessage.StockCode)
{
case "S01":
reservedStockCount = 14;
totalStockCount = 80;
break;
case "S02":
reservedStockCount = 0;
totalStockCount = 25;
break;
default:
reservedStockCount = -1;
totalStockCount = -1;
break;
}
//Create a reply message for stock query
var stockQueryResult = new StockQueryResultMessage
{
StockCode = stockQueryMessage.StockCode,
ReservedStockCount = reservedStockCount,
TotalStockCount = totalStockCount
};
//Create a MDS response message to send to client
var responseMessage = e.Message.CreateResponseMessage();
responseMessage.MessageData = GeneralHelper.SerializeObject(stockQueryResult);
//Send message
responseMessage.Send();
//Acknowledge the original request message. So, it will be deleted from queue.
e.Message.Acknowledge();
}
/// <summary>
/// This method handles received messages from other applications via DotNetMQ.
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Message parameters</param>
private void PLCServer_MessageReceived(object sender, MessageReceivedEventArgs e)
{
// Get message
var Message = e.Message;
// Acknowledge that message is properly handled and processed. So, it will be deleted from queue.
e.Message.Acknowledge();
// Get message data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as MsgData;
try
{
switch (MsgData.MsgCode)
{
case MsgCodes.ConnectSubscriber: ConnectSubscriber(Message); break;
case MsgCodes.DisconnectSubscriber: DisconnectSubscriber(Message); break;
case MsgCodes.SubscribePLCTag: SubscribePLCTag(Message); break;
case MsgCodes.SubscribePLCTags: SubscribePLCTags(Message); break;
case MsgCodes.RemovePLCTag: RemovePLCTag(Message); break;
case MsgCodes.RemovePLCTags: RemovePLCTags(Message); break;
case MsgCodes.GetSubscribedPLCTags: GetSubscribedPLCTags(Message); break;
case MsgCodes.SetPLCTags: SetPLCTags(Message); break;
case MsgCodes.GetPLCTags: GetPLCTags(Message); break;
case MsgCodes.SetPLCTag: SetPLCTag(Message); break;
case MsgCodes.GetPLCTag: GetPLCTag(Message); break;
case MsgCodes.StartCheckPLCTags: StartCheckPLCTags(Message); break;
case MsgCodes.StopCheckPLCTags: StopCheckPLCTags(Message); break;
case MsgCodes.GetPLCStatus: GetPLCStatus(Message); break;
case MsgCodes.ConnectPLC: ConnectPLC(Message); break;
case MsgCodes.DisconnectPLC: DisconnectPLC(Message); break;
}
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
}
}
/// <summary>
/// Ricezione messaggio di valore di plctag sottoscritto cambiato
/// se la property associata è sottoscritta invio messaggio di notifica al sottoscrittore
/// </summary>
/// <param name="Message"></param>
/// <returns><c>true</c> if the tag is effectively subscribed; otherwise, <c>false</c>.</returns>
private bool PLCTagChanged(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagData;
var plctag = MsgData.Tag;
Logger.InfoFormat("{0} -> {1}/{2}:{3}", Message.SourceApplicationName, plctag.PLCName, plctag.Address, plctag.Value);
// trova il tag corrispondente all'indirizzo sottoscritto
TagItem tag;
if ((tag = ListTagItems.FirstOrDefault(item => item.PLCName == plctag.PLCName && item.Address == plctag.Address)) != null)
{
//
try
{
tag.Value = MsgData.Tag.Value;
}
catch (Exception exc)
{
Logger.WarnFormat("Errore in cambio Tag value {0} : {1}/{2}:{3} -> {4} {5}", tag.Name, tag.PLCName, tag.Address, tag.Type, tag.Value, exc.Message);
RetValue = false;
}
// recupero la lista delle properties dell'impianto
// LG: Ma la uso anche in SubscribePLCTags!!! Devo fare tutte le volte sta roba?
List <PropertyObject> props = dataManager.PathObjectsDictionary.Values.Where(item => item.GetType() == typeof(PropertyObject)).Cast <PropertyObject>().ToList();
// trova la property associata e cambia il valore
PropertyObject property = props.FirstOrDefault(prp => prp.bind == tag.Name);
if (property != null)
{
try
{
property.value = tag.Value;
}
catch (Exception exc)
{
Logger.WarnFormat("Errore in cambio valore property {0}:{1} {2}", property.path, tag.Value, exc.Message);
RetValue = false;
}
}
}
else
{
Logger.InfoFormat("Tag associato a : {0}/{1} non trovato", plctag.PLCName, plctag.Address);
RetValue = false;
}
return(RetValue);
}
/// <summary>
/// Implementazione esecuzione comando di richiesta valore lista plctags
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool GetPLCTags(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagsData;
var tagslist = MsgData.Tags;
Logger.InfoFormat("{0}", Message.SourceApplicationName);
for (int i = 0; i < tagslist.Count; i++)
{
var tag = tagslist[i];
// verifico connessione/esistenza PLC interessato
if (!_PLCs.ContainsKey(tag.PLCName))
{
// log
Logger.WarnFormat("PLC [{1}] not connected", tag.PLCName);
tag.Validation = true;
RetValue = false;
}
else
{
try
{
/* leggo tag value */
var plctag = _PLCs[tag.PLCName].Read(new S7NetWrapper.Tag(tag.Address));
if (plctag != null)
{
tag.Value = plctag.ItemValue;
tag.Validation = true;
}
}
catch (Exception exc)
{
// log
Logger.WarnFormat("PLC [{0}] error reading tag {1} : {2}", tag.PLCName, tag.Address, exc.Message);
tag.Validation = true;
RetValue = false;
}
}
}
// invio messaggio di risposta generica
return(SendResponse(Message, MsgCodes.ResultGetPLCTags, new PLCTagsData()
{
MsgCode = MsgCodes.ResultGetPLCTags, Tags = tagslist
}, RetValue));
}
/// <summary>
/// Implementazione esecuzione comando di rimozione di un plctags
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool RemovePLCTag(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagData;
var tag = MsgData.Tag;
RetValue = RemovePLCTag(Message.SourceApplicationName, tag);
// invio messaggio di risposta generica
return(SendResponse(Message, MsgCodes.ResultRemovePLCTag, MsgData, RetValue));
}
/// <summary>
/// This method handles all incoming messages from MDS server.
/// </summary>
/// <param name="sender">Creator object of method (MDSClient object)</param>
/// <param name="e">Message event arguments</param>
private void MdsClient_MessageReceived(object sender, MessageReceivedEventArgs e)
{
//Deserialize message
MDSRemoteInvokeMessage invokeMessage;
try
{
invokeMessage = (MDSRemoteInvokeMessage)GeneralHelper.DeserializeObject(e.Message.MessageData);
}
catch (Exception ex)
{
AcknowledgeMessage(e.Message);
SendException(e.Message, new MDSRemoteException("Incoming message can not be deserialized to MDSRemoteInvokeMessage.", ex));
return;
}
//Check service class name
if (!_serviceObjects.ContainsKey(invokeMessage.ServiceClassName))
{
AcknowledgeMessage(e.Message);
SendException(e.Message, new MDSRemoteException("There is no service with name '" + invokeMessage.ServiceClassName + "'"));
return;
}
//Get service object
var serviceObject = _serviceObjects[invokeMessage.ServiceClassName];
//Invoke service method and get return value
object returnValue;
try
{
//Set request variables to service object and invoke method
serviceObject.Service.IncomingMessage = e.Message;
returnValue = serviceObject.InvokeMethod(invokeMessage.MethodName, invokeMessage.Parameters);
}
catch (Exception ex)
{
SendException(e.Message,
new MDSRemoteException(
ex.Message + Environment.NewLine + "Service Class: " +
invokeMessage.ServiceClassName + " " + Environment.NewLine +
"Service Version: " + serviceObject.ServiceAttribute.Version, ex));
return;
}
//Send return value to sender application
SendReturnValue(e.Message, returnValue);
}
/// <summary>
/// Implementazione esecuzione comando di richiesta valore plctag
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool GetPLCTag(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagData;
var tag = MsgData.Tag;
Logger.InfoFormat("{0}/{1} da {2}", tag.PLCName, tag.Address, Message.SourceApplicationName);
RetValue = GetPLCTag(ref tag);
// invio messaggio di risposta generica
return(SendResponse(Message, MsgCodes.ResultGetPLCTag, MsgData, RetValue));
}
private bool RemoveProperty(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PropertyData;
var prop = MsgData.Prop;
Logger.InfoFormat("{1} da {0}", Message.SourceApplicationName, prop.ObjPath);
RetValue = RemoveProperty(Message.SourceApplicationName, prop);
/* invio messaggio di risposta */
return(SendResponse(Message, MsgCodes.ResultRemoveProperty, MsgData, RetValue));
}
private bool ResultConnectSubscriber(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as MsgData;
Logger.InfoFormat("Ricevuto Messaggio {1} da {0}", Message.SourceApplicationName, MsgData.validation);
RetValue = MsgData.validation;
model.ConnectionState = true;
return(RetValue);
}
/// <summary>
/// This method handles received messages from other applications via DotNetMQ.
/// </summary>
/// <param name="sender"></param>
/// <param name="e">Message parameters</param>
private void hmi_MessageReceived(object sender, MessageReceivedEventArgs e)
{
try
{
// Get message
var Message = e.Message;
// Acknowledge that message is properly handled and processed. So, it will be deleted from queue.
e.Message.Acknowledge();
// Get message data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as MsgData;
Logger.InfoFormat("Ricevuto Messaggio {0}", MsgData.MsgCode);
switch (MsgData.MsgCode)
{
case MsgCodes.PLCTagsChanged: /* gestione da fare */ break;
case MsgCodes.PLCTagChanged: PLCTagChanged(Message); break;
case MsgCodes.PLCStatus: PLCStatus(Message); break;
case MsgCodes.ResultSubscribePLCTag: ResultSubscribePLCTag(Message); break;
case MsgCodes.ResultSubscribePLCTags: break;
case MsgCodes.ResultSetPLCTag: break;
case MsgCodes.ResultSetPLCTags: break;
case MsgCodes.ResultConnectSubscriber: ResultConnectSubscriber(Message); break;
case MsgCodes.ResultDisconnectSubscriber: ResultDisconnectSubscriber(Message); break;
case MsgCodes.ResultConnectPLC: ResultConnectPLC(Message); break;
case MsgCodes.ResultDisconnectPLC: ResultDisconnectPLC(Message); break;
}
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
}
}
/// <summary>
/// Implementazione esecuzione comando di set valore lista plctags
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool SetPLCTags(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCTagsData;
var tagslist = MsgData.Tags;
Logger.InfoFormat("{0}", Message.SourceApplicationName);
for (int i = 0; i < tagslist.Count; i++)
{
var tag = tagslist[i];
/* verifico connessione/esistenza PLC interessato */
if (!_PLCs.ContainsKey(tag.PLCName))
{
// log
Logger.WarnFormat("PLC [{0}] not connected", tag.PLCName);
tag.Validation = false;
RetValue = false;
}
else
{
try
{
/* scrivo tag */
var plctag = new S7NetWrapper.Tag(tag.Address, tag.Value);
_PLCs[tag.PLCName].Write(plctag);
tag.Validation = true;
}
catch (Exception exc)
{
// log
Logger.WarnFormat("PLC [{0}] error writing tag {1} : {2}", tag.PLCName, tag.Address, exc.Message);
tag.Validation = false;
RetValue = false;
}
}
}
/* invio messaggio di risposta generica */
return(SendResponse(Message, MsgCodes.ResultSetPLCTags, MsgData, RetValue));
}
private bool PropertyChanged(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PropertyData;
var prop = MsgData.Prop;
Logger.InfoFormat("Ricevuto Messaggio {1}:{2} da {0}", Message.SourceApplicationName, prop.ObjPath, prop.Value);
RetValue = PropertyChanged(prop);
if (RetValue == false)
{
Logger.InfoFormat("Property {0} non trovata", prop.ObjPath);
}
return(RetValue);
}
/// <summary>
/// Implementazione esecuzione comando di richiesta plc status
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool GetPLCStatus(IIncomingMessage Message)
{
bool RetValue = true;
PLCConnectionStatus ConnectionStatus;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCData;
Logger.InfoFormat("{0} da {1}", MsgData.PLCName, Message.SourceApplicationName);
if (!_PLCs.ContainsKey(MsgData.PLCName))
{
// log
Logger.WarnFormat("PLC [{0}] not connected", MsgData.PLCName);
ConnectionStatus = PLCConnectionStatus.NotConnected;
RetValue = false;
}
else
{
var plc = _PLCs[MsgData.PLCName];
switch (plc.ConnectionState)
{
case S7NetWrapper.ConnectionStates.Connecting:
ConnectionStatus = PLCConnectionStatus.InConnection;
break;
default:
case S7NetWrapper.ConnectionStates.Offline:
ConnectionStatus = PLCConnectionStatus.NotConnected;
break;
case S7NetWrapper.ConnectionStates.Online:
ConnectionStatus = PLCConnectionStatus.Connected;
break;
}
}
// invio messaggio di risposta generica
return(SendResponse(Message, MsgCodes.PLCStatus, new PLCStatusData {
PLCName = MsgData.PLCName, Status = ConnectionStatus
}, RetValue));
}
static void Main(string[] args)
{
Console.WriteLine("Press enter to query a stock status");
Console.ReadLine();
//Connect to DotNetMQ
var mdsClient = new MDSClient("StockClient");
mdsClient.MessageReceived += mdsClient_MessageReceived;
mdsClient.Connect();
//Create a stock request message
var stockQueryMessage = new StockQueryMessage {
StockCode = "S01"
};
//Create a MDS message
var requestMessage = mdsClient.CreateMessage();
requestMessage.DestinationApplicationName = "StockServer";
requestMessage.TransmitRule = MessageTransmitRules.NonPersistent;
requestMessage.MessageData = GeneralHelper.SerializeObject(stockQueryMessage);
//Send message and get response
var responseMessage = requestMessage.SendAndGetResponse();
//Get stock query result message from response message
var stockResult = (StockQueryResultMessage)GeneralHelper.DeserializeObject(responseMessage.MessageData);
//Write stock query result
Console.WriteLine("StockCode = " + stockResult.StockCode);
Console.WriteLine("ReservedStockCount = " + stockResult.ReservedStockCount);
Console.WriteLine("TotalStockCount = " + stockResult.TotalStockCount);
//Acknowledge received message
responseMessage.Acknowledge();
Console.ReadLine();
//Disconnect from DotNetMQ server.
mdsClient.Disconnect();
}
/// <summary>
/// Implementazione esecuzione comando di connessione di un plc
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool ConnectPLC(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCConnectionData;
Logger.InfoFormat("{1}-{2}-{3}-{4}-{5}-{6} da {0}", Message.SourceApplicationName, MsgData.PLCName, MsgData.Cputype.ToString(), MsgData.IpAddress, MsgData.Rack, MsgData.Slot, MsgData.Delay);
if (!_Subs.ContainsKey(Message.SourceApplicationName))
{
Logger.WarnFormat("[{0}] not subscribed", Message.SourceApplicationName);
RetValue = false;
}
else
{
RetValue = ConnectPLC(MsgData);
}
// invio messaggio di risposta generica
return(SendResponse(Message, MsgCodes.ResultConnectPLC, MsgData, RetValue));
}
/// <summary>
/// Implementazione esecuzione comando di disconnessione di un plc
/// </summary>
/// <param name="Message">Dati messaggio ricevuto</param>
/// <returns>true se tutto bene, altrimenti false</returns>
private bool DisconnectPLC(IIncomingMessage Message)
{
bool RetValue = true;
// get msg application data
var MsgData = GeneralHelper.DeserializeObject(Message.MessageData) as PLCData;
Logger.InfoFormat("{1} da {0}", Message.SourceApplicationName, MsgData.PLCName);
if (!_Subs.ContainsKey(Message.SourceApplicationName))
{
Logger.WarnFormat("[{0}] not subscribed", Message.SourceApplicationName);
RetValue = false;
}
else
{
RetValue = DisconnectPLC(MsgData);
}
// invio messaggio di risposta generica
return(SendResponse(Message, MsgCodes.ResultDisconnectPLC, MsgData, RetValue));
}
