Beispiel #1
0
        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);
        }