private void cmdAddConnection_Click(object sender, RoutedEventArgs e)
{
string val = "Connection_" + (grdConnections.Items.Count + 1);
if (DotNetSiemensPLCToolBoxLibrary.General.InputBox.Show("Connectionname", "Name of the PLC Connection", ref val) == DialogResult.OK)
{
foreach (ConnectionConfig plcConnectionConfiguration in ProtokollerConfiguration.ActualConfigInstance.Connections)
{
if (plcConnectionConfiguration.Name.ToLower().Trim() == val.ToLower().Trim())
{
MessageBox.Show("A Connection with this Name already Exists!", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
}
PLCConnectionConfiguration myIntConfig = new PLCConnectionConfiguration(val.Trim(), LibNodaveConnectionConfigurationType.ObjectSavedConfiguration);
myIntConfig = DotNetSiemensPLCToolBoxLibrary.Communication.Configuration.ShowConfiguration(myIntConfig);
if (myIntConfig != null)
{
LibNoDaveConfig myConfig = new LibNoDaveConfig();
myConfig.Configuration = myIntConfig;
ProtokollerConfiguration.ActualConfigInstance.Connections.Add(myConfig);
}
//grdConnections.Items.Add(myConfig);
}
}
private void synchronizePLCTimes(object tmp)
{
foreach (ConnectionConfig connectionConfig in akConfig.Connections)
{
LibNoDaveConfig plcConnConf = connectionConfig as LibNoDaveConfig;
if (plcConnConf != null)
{
PLCConnection tmpConn = (PLCConnection)ConnectionList[connectionConfig];
if (plcConnConf.SynchronizePLCTime)
{
try
{
if (!tmpConn.Connected)
{
tmpConn.Connect();
}
tmpConn.PLCSetTime(DateTime.Now);
if (!plcConnConf.StayConnected)
{
tmpConn.Disconnect();
}
}
catch (Exception ex)
{ }
}
}
}
}
private void ReEstablishConnectionsThreadProc(object config)
{
try
{
LibNoDaveConfig connectionConfig = config as LibNoDaveConfig;
while (true)
{
if (ConnectionList.ContainsKey(connectionConfig))
{
PLCConnection plcConn = ConnectionList[connectionConfig] as PLCConnection;
if (plcConn != null && !plcConn.Connected && ((LibNoDaveConfig)connectionConfig).StayConnected)
{
try
{
plcConn.Connect();
Logging.LogText("Connection: " + connectionConfig.Name + " connected", Logging.LogLevel.Information);
}
catch (ThreadAbortException ex)
{
throw ex;
}
catch (Exception ex)
{
Logging.LogText("Connection: " + connectionConfig.Name, ex, Logging.LogLevel.Warning);
}
}
}
Thread.Sleep(connectionConfig.ReconnectInterval);
}
}
catch (ThreadAbortException)
{
}
}
private void synchronizePLCTimes(object tmp)
{
foreach (ConnectionConfig connectionConfig in akConfig.Connections)
{
LibNoDaveConfig plcConnConf = connectionConfig as LibNoDaveConfig;
if (plcConnConf != null)
{
PLCConnection tmpConn = (PLCConnection)ConnectionList[connectionConfig];
if (plcConnConf.SynchronizePLCTime)
{
try
{
if (!tmpConn.Connected)
{
Logging.LogTextToLog4Net("synchronizePLCTimes() => \"" + plcConnConf.Name + "\" => Connect...");
tmpConn.Connect();
}
tmpConn.PLCSetTime(DateTime.Now);
if (!plcConnConf.StayConnected)
{
Logging.LogTextToLog4Net("synchronizePLCTimes() => \"" + plcConnConf.Name + "\" Discconnect because !StayConnected");
tmpConn.Disconnect();
}
}
catch (Exception ex)
{ }
}
}
}
}
private void PropertyGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
if (prpGrid.SelectedProperty.Value is PLCConnectionConfiguration)
{
LibNoDaveConfig myConfig = (LibNoDaveConfig)grdConnections.SelectedItem;
myConfig.Configuration = DotNetSiemensPLCToolBoxLibrary.Communication.Configuration.ShowConfiguration(myConfig.Configuration);
}
}
private void grdConnections_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
if (grdConnections.SelectedItem != null)
{
if (grdConnections.SelectedItem is LibNoDaveConfig)
{
LibNoDaveConfig myConfig = (LibNoDaveConfig)grdConnections.SelectedItem;
myConfig.Configuration = DotNetSiemensPLCToolBoxLibrary.Communication.Configuration.ShowConfiguration(myConfig.Configuration);
}
}
}
private void EstablishConnections()
{
foreach (ConnectionConfig connectionConfig in akConfig.Connections)
{
LibNoDaveConfig plcConnConf = connectionConfig as LibNoDaveConfig;
TCPIPConfig tcpipConnConf = connectionConfig as TCPIPConfig;
DatabaseConfig dbConnConf = connectionConfig as DatabaseConfig;
if (plcConnConf != null)
{
Logging.LogText("Connection: " + connectionConfig.Name + " is starting...", Logging.LogLevel.Information);
PLCConnection tmpConn = new PLCConnection(plcConnConf.Configuration);
try
{
tmpConn.Connect();
if (!plcConnConf.StayConnected)
{
tmpConn.Disconnect();
}
}
catch (Exception ex)
{
Logging.LogText("Connection: " + connectionConfig.Name, ex, Logging.LogLevel.Warning);
}
ConnectionList.Add(connectionConfig, tmpConn);
}
else if (dbConnConf != null)
{
var tmpConn = new DatabaseConnection(dbConnConf);
try
{
tmpConn.Connect();
}
catch (Exception ex)
{
Logging.LogText("Connection: " + connectionConfig.Name, ex, Logging.LogLevel.Warning);
}
ConnectionList.Add(connectionConfig, tmpConn);
}
else if (tcpipConnConf != null)
{
//todo: legth of tcp conn
//TCPFunctionsAsync tmpConn = new TCPFunctionsAsync(new SynchronizationContext(), tcpipConnConf.IPasIPAddres, tcpipConnConf.Port, !tcpipConnConf.PassiveConnection, 0);
//tmpConn.Connect();
//ConnectionList.Add(connectionConfig, tmpConn);
}
}
myReEstablishConnectionsThreads = new List <Thread>();
foreach (ConnectionConfig connectionConfig in akConfig.Connections)
{
if (connectionConfig is LibNoDaveConfig)
{
var thrd = new Thread(new ParameterizedThreadStart(ReEstablishConnectionsThreadProc))
{
Name = "EstablishConnectionsThreadProc"
};
thrd.Start(connectionConfig as LibNoDaveConfig);
this.myReEstablishConnectionsThreads.Add(thrd);
}
}
}
public string CheckConfiguration(bool TestConnections)
{
string error = "";
var ConnectionList = new Dictionary <ConnectionConfig, PLCConnection>();
//Try to Connect to the PLCs
if (TestConnections)
{
foreach (ConnectionConfig connectionConfig in Connections)
{
LibNoDaveConfig lConn = connectionConfig as LibNoDaveConfig;
if (lConn != null)
{
using (PLCConnection myConn = new PLCConnection(lConn.Configuration))
{
try
{
myConn.Connect();
ConnectionList.Add(connectionConfig, myConn);
}
catch (Exception ex)
{
error += "Error: Error connecting \"" + lConn.Name + "\" : " + ex.Message + Environment.NewLine;
}
}
}
}
}
var TCPIPKeys = new Dictionary <string, int>();
foreach (DatasetConfig datasetConfig in Datasets)
{
var DatasetConnectionKeys = new Dictionary <string, object>();
//Look if TCPIP Connection is only used in one Dataset, because we need the length for each Connection!
try
{
if (datasetConfig.DatasetConfigRows.Count > 0)
{
if (datasetConfig.DatasetConfigRows[0].Connection != null)
{
var tcp = datasetConfig.DatasetConfigRows[0].Connection as TCPIPConfig;
var byteCount = ReadData.GetCountOfBytesToRead(datasetConfig.DatasetConfigRows);
if (tcp != null && !tcp.DontUseFixedTCPLength)
{
if (!TCPIPKeys.ContainsKey(datasetConfig.DatasetConfigRows[0].Connection.Name))
{
TCPIPKeys.Add(datasetConfig.DatasetConfigRows[0].Connection.Name, byteCount);
}
if (TCPIPKeys[datasetConfig.DatasetConfigRows[0].Connection.Name] != byteCount)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" - The same TCP/IP Connection is used in more than one Dataset with differnet bytes sizes, but fixed Length should be used!" + Environment.NewLine;
}
}
}
}
else
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" - No DatasetConfigRow is set!" + Environment.NewLine;
}
}
catch
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" - The same TCP/IP Connection is used in more than one Dataset!" + Environment.NewLine;
}
//Look if Trigger on a Dataset with TCP/IP Connection is Incoming Data, and that this trigger is not used on a Connection without TCP/IP
try
{
if (!(datasetConfig.TriggerConnection is TCPIPConfig && (datasetConfig.Trigger == DatasetTriggerType.Triggered_By_Incoming_Data_On_A_TCPIP_Connection)))
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" - The selected Connection for incoming Trigger is no TCP/IP Connection !" + Environment.NewLine;
}
}
catch { }
//Look if Trigger Connection was selected (Handshake Trigger)
if (datasetConfig.Trigger == DatasetTriggerType.Tags_Handshake_Trigger && datasetConfig.TriggerConnection == null)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Trigger Connection not set!" + Environment.NewLine;
}
//Look if Trigger Connection was selected (TCPIP Trigger)
if (datasetConfig.Trigger == DatasetTriggerType.Triggered_By_Incoming_Data_On_A_TCPIP_Connection && datasetConfig.TriggerConnection == null)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Trigger Connection not set!" + Environment.NewLine;
}
if (datasetConfig.Storage == null)
{
error += "Error: Dataset \"" + datasetConfig.Name + " - Storage is not set!" + Environment.NewLine;
}
foreach (DatasetConfigRow datasetConfigRow in datasetConfig.DatasetConfigRows)
{
if (datasetConfigRow.Connection == null && datasetConfig.Trigger != DatasetTriggerType.Triggered_By_Incoming_Data_On_A_TCPIP_Connection)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Row \"" + datasetConfigRow.DatabaseField + "\" - Connection not Set!" + Environment.NewLine;
}
}
if (datasetConfig.Trigger == DatasetTriggerType.Tags_Handshake_Trigger && datasetConfig.TriggerConnection == null)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Trigger Connection not set!" + Environment.NewLine;
}
foreach (DatasetConfigRow datasetConfigRow in datasetConfig.DatasetConfigRows)
{
//Look if PLC-Connection was selected
if (datasetConfigRow.Connection == null && datasetConfig.Trigger != DatasetTriggerType.Triggered_By_Incoming_Data_On_A_TCPIP_Connection)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Row \"" + datasetConfigRow.DatabaseField + "\" - Connection not Set!" + Environment.NewLine;
}
//Look if DatabaseFieldType was selected
if (datasetConfigRow.DatabaseFieldType == "")
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Row \"" + datasetConfigRow.DatabaseField + "\" - DatabaseFieldType not Set!" + Environment.NewLine;
}
////Look if PLC-ValueType was selected
if (datasetConfigRow.PLCTag.LibNoDaveDataType == null)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Row \"" + datasetConfigRow.DatabaseField + "\" - PLC-ValueType not Set!" + Environment.NewLine;
}
if (TestConnections && datasetConfig.Trigger != DatasetTriggerType.Triggered_By_Incoming_Data_On_A_TCPIP_Connection)
{
PLCConnection conn = null as PLCConnection;
if (datasetConfigRow.Connection != null)
{
try
{
conn = ConnectionList[datasetConfigRow.Connection] as PLCConnection;
}
catch
{
conn = null;
}
}
else
{
conn = null;
}
if (conn != null)
{
try
{
conn.ReadValue(datasetConfigRow.PLCTag);
if (datasetConfigRow.PLCTag.ItemDoesNotExist)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Row \"" + datasetConfigRow.DatabaseField + "\" - Error Reading Value on Address " + datasetConfigRow.PLCTag.S7FormatAddress + " !" + Environment.NewLine;
}
}
catch (Exception ex)
{
error += "Error: Dataset \"" + datasetConfig.Name + "\" Row \"" + datasetConfigRow.DatabaseField + "\" - Error Reading Value on Address " + datasetConfigRow.PLCTag.S7FormatAddress + " !" + Environment.NewLine;
}
}
}
}
}
//Look if Connection Name exists only once
var ConnectionNames = new List <string>();
var ConnectionKeys = new Dictionary <string, object>();
foreach (ConnectionConfig item in Connections)
{
if (ConnectionKeys.ContainsKey(item.Name))
{
error += "Error: Connection name \"" + item.Name + "\" - exist more than once!" + Environment.NewLine;
}
else
{
ConnectionKeys.Add(item.Name, null);
}
}
//Look if Storrage Name exists only once
var StorageNames = new List <string>();
var StoragesKeys = new Dictionary <string, object>();
foreach (StorageConfig item in Storages)
{
if (StoragesKeys.ContainsKey(item.Name))
{
error += "Error: Storage name \"" + item.Name + "\" - exist more than once!" + Environment.NewLine;
}
else
{
StoragesKeys.Add(item.Name, null);
}
}
//Look if the Database Field Type is in the Field Types List
//Look if Field Name Exists only Once -> This is possible in excel, but not in databases
if (error == "")
{
return(null);
}
return(error);
}
