Exemple #1
0
        // ReSharper disable once UnusedMethodReturnValue.Local
        private static bool SerializeEcuFunction(TextWriter outTextWriter, TextWriter logTextWriter, string connection, string outDirSub, string ecuName)
        {
            try
            {
                using (SQLiteConnection mDbConnection = new SQLiteConnection(connection))
                {
                    mDbConnection.SetPassword(DbPassword);
                    mDbConnection.Open();

                    outTextWriter?.WriteLine("*** ECU: {0} ***", ecuName);
                    EcuFunctionStructs.EcuVariant ecuVariant = GetEcuVariantFunctions(outTextWriter, logTextWriter, mDbConnection, ecuName);

                    if (ecuVariant != null)
                    {
                        logTextWriter?.WriteLine(ecuVariant);

                        string        xmlFile    = Path.Combine(outDirSub, ecuName.ToLowerInvariant() + ".xml");
                        XmlSerializer serializer = new XmlSerializer(ecuVariant.GetType());
                        using (TextWriter writer = new StreamWriter(xmlFile))
                        {
                            serializer.Serialize(writer, ecuVariant);
                        }
                    }

                    mDbConnection.Close();
                }

                return(true);
            }
            catch (Exception e)
            {
                outTextWriter?.WriteLine(e);
                return(false);
            }
        }
Exemple #2
0
        static List <EcuFunctionStructs.EcuFixedFuncStruct> GetFixedFuncStructList(EcuFunctionStructs.EcuVariant ecuVariant)
        {
            List <EcuFunctionStructs.EcuFixedFuncStruct> fixedFuncStructList = new List <EcuFunctionStructs.EcuFixedFuncStruct>();

            if (ecuVariant.RefEcuVariantList != null)
            {
                foreach (EcuFunctionStructs.RefEcuVariant refEcuVariant in ecuVariant.RefEcuVariantList)
                {
                    if (refEcuVariant.FixedFuncStructList != null)
                    {
                        fixedFuncStructList.AddRange(refEcuVariant.FixedFuncStructList);
                    }
                }
            }

            if (ecuVariant.EcuFuncStructList != null)
            {
                foreach (EcuFunctionStructs.EcuFuncStruct ecuFuncStruct in ecuVariant.EcuFuncStructList)
                {
                    if (ecuFuncStruct.FixedFuncStructList != null)
                    {
                        fixedFuncStructList.AddRange(ecuFuncStruct.FixedFuncStructList);
                    }
                }
            }

            return(fixedFuncStructList);
        }
Exemple #3
0
        private static EcuFunctionStructs.EcuVariant GetEcuVariant(SQLiteConnection mDbConnection, string ecuName)
        {
            EcuFunctionStructs.EcuVariant ecuVariant = null;
            string sql = string.Format(@"SELECT ID, " + SqlTitleItems + ", ECUGROUPID FROM XEP_ECUVARIANTS WHERE (lower(NAME) = '{0}')", ecuName.ToLowerInvariant());

            using (SQLiteCommand command = new SQLiteCommand(sql, mDbConnection))
            {
                using (SQLiteDataReader reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        string groupId = reader["ECUGROUPID"].ToString();
                        ecuVariant = new EcuFunctionStructs.EcuVariant(reader["ID"].ToString(),
                                                                       groupId,
                                                                       GetTranslation(reader),
                                                                       GetEcuGroupFunctionIds(mDbConnection, groupId));
                    }
                }
            }

            return(ecuVariant);
        }
Exemple #4
0
        static bool MergeEcuVariant(TextWriter outTextWriter, string fileName, EcuFunctionStructs.EcuVariant ecuVariantIn, EcuFunctionStructs.EcuVariant ecuVariantMerge)
        {
            List <EcuFunctionStructs.EcuFixedFuncStruct> fixedFuncStructListIn    = GetFixedFuncStructListRead(ecuVariantIn);
            List <EcuFunctionStructs.EcuFixedFuncStruct> fixedFuncStructListMerge = GetFixedFuncStructListRead(ecuVariantMerge);

            bool matched = false;

            foreach (EcuFunctionStructs.EcuFixedFuncStruct ecuFixedFuncStruct in fixedFuncStructListMerge)
            {
                if (ecuFixedFuncStruct.EcuJobList != null)
                {
                    foreach (EcuFunctionStructs.EcuJob ecuJob in ecuFixedFuncStruct.EcuJobList)
                    {
                        if (MergeEcuJob(outTextWriter, fileName, fixedFuncStructListIn, ecuJob, ecuFixedFuncStruct) > 0)
                        {
                            matched = true;
                        }
                    }
                }
            }
            return(matched);
        }
Exemple #5
0
        private static EcuFunctionStructs.EcuVariant GetEcuVariantFunctions(TextWriter outTextWriter, TextWriter logTextWriter, SQLiteConnection mDbConnection, string ecuName)
        {
            EcuFunctionStructs.EcuVariant ecuVariant = GetEcuVariant(mDbConnection, ecuName);
            if (ecuVariant == null)
            {
                outTextWriter?.WriteLine("ECU variant not found");
                return(null);
            }

            ecuVariant.EcuFaultCodeList = GetFaultCodes(mDbConnection, ecuVariant.Id);

            List <EcuFunctionStructs.RefEcuVariant> refEcuVariantList = new List <EcuFunctionStructs.RefEcuVariant>();
            {
                string sql = string.Format(@"SELECT ID, ECUVARIANTID FROM XEP_REFECUVARIANTS WHERE ECUVARIANTID = {0}", ecuVariant.Id);
                using (SQLiteCommand command = new SQLiteCommand(sql, mDbConnection))
                {
                    using (SQLiteDataReader reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            refEcuVariantList.Add(new EcuFunctionStructs.RefEcuVariant(reader["ID"].ToString(),
                                                                                       reader["ECUVARIANTID"].ToString()));
                        }
                    }
                }
            }

            int fixFuncCount = 0;

            ecuVariant.RefEcuVariantList = refEcuVariantList;

            foreach (EcuFunctionStructs.RefEcuVariant refEcuVariant in refEcuVariantList)
            {
                List <EcuFunctionStructs.EcuFixedFuncStruct> ecuFixedFuncStructList = GetEcuFixedFuncStructList(mDbConnection, refEcuVariant.Id);
                fixFuncCount += ecuFixedFuncStructList.Count;
                refEcuVariant.FixedFuncStructList = ecuFixedFuncStructList;
            }

            List <EcuFunctionStructs.EcuVarFunc> ecuVarFunctionsList = new List <EcuFunctionStructs.EcuVarFunc>();

            foreach (string ecuGroupFunctionId in ecuVariant.GroupFunctionIds)
            {
                string sql = string.Format(@"SELECT ID, VISIBLE, NAME, OBD_RELEVANZ FROM XEP_ECUVARFUNCTIONS WHERE (lower(NAME) = '{0}') AND (ECUGROUPFUNCTIONID = {1})", ecuName.ToLowerInvariant(), ecuGroupFunctionId);
                using (SQLiteCommand command = new SQLiteCommand(sql, mDbConnection))
                {
                    using (SQLiteDataReader reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            ecuVarFunctionsList.Add(new EcuFunctionStructs.EcuVarFunc(reader["ID"].ToString(), ecuGroupFunctionId));
                        }
                    }
                }
            }

            foreach (EcuFunctionStructs.EcuVarFunc ecuVarFunc in ecuVarFunctionsList)
            {
                logTextWriter?.WriteLine(ecuVarFunc);
            }

            List <EcuFunctionStructs.EcuFuncStruct> ecuFuncStructList = new List <EcuFunctionStructs.EcuFuncStruct>();

            foreach (EcuFunctionStructs.EcuVarFunc ecuVarFunc in ecuVarFunctionsList)
            {
                string sql = string.Format(@"SELECT REFFUNCS.ECUFUNCSTRUCTID FUNCSTRUCTID, " + SqlTitleItems + ", MULTISELECTION " +
                                           "FROM XEP_ECUFUNCSTRUCTURES FUNCS, XEP_REFECUFUNCSTRUCTS REFFUNCS WHERE FUNCS.ID = REFFUNCS.ECUFUNCSTRUCTID AND REFFUNCS.ID = {0}", ecuVarFunc.Id);
                using (SQLiteCommand command = new SQLiteCommand(sql, mDbConnection))
                {
                    using (SQLiteDataReader reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            ecuFuncStructList.Add(new EcuFunctionStructs.EcuFuncStruct(reader["FUNCSTRUCTID"].ToString(),
                                                                                       GetTranslation(reader),
                                                                                       reader["MULTISELECTION"].ToString()));
                        }
                    }
                }
            }

            foreach (EcuFunctionStructs.EcuFuncStruct ecuFuncStruct in ecuFuncStructList)
            {
                List <EcuFunctionStructs.EcuFixedFuncStruct> ecuFixedFuncStructList = GetEcuFixedFuncStructList(mDbConnection, ecuFuncStruct.Id);
                fixFuncCount += ecuFixedFuncStructList.Count;
                ecuFuncStruct.FixedFuncStructList = ecuFixedFuncStructList;

                if (ecuFuncStruct.MultiSelect.ConvertToInt() > 0)
                {
                    foreach (EcuFunctionStructs.EcuFixedFuncStruct ecuFixedFuncStruct in ecuFixedFuncStructList)
                    {
                        if (ecuFixedFuncStruct.GetNodeClassType() == EcuFunctionStructs.EcuFixedFuncStruct.NodeClassType.ControlActuator)
                        {
                            outTextWriter.WriteLine("Actuator multi select!");
                        }
                    }
                }
            }

            if (fixFuncCount == 0)
            {
                outTextWriter?.WriteLine("No ECU fix functions found");
                return(null);
            }

            ecuVariant.EcuFuncStructList = ecuFuncStructList;

            return(ecuVariant);
        }
Exemple #6
0
        static List <EcuFunctionStructs.EcuFixedFuncStruct> GetFixedFuncStructListRead(EcuFunctionStructs.EcuVariant ecuVariant)
        {
            List <EcuFunctionStructs.EcuFixedFuncStruct> fixedFuncStructList     = GetFixedFuncStructList(ecuVariant);
            List <EcuFunctionStructs.EcuFixedFuncStruct> fixedFuncStructListRead = new List <EcuFunctionStructs.EcuFixedFuncStruct>();

            foreach (EcuFunctionStructs.EcuFixedFuncStruct ecuFixedFunc in fixedFuncStructList)
            {
                if (ecuFixedFunc.GetNodeClassType() != EcuFunctionStructs.EcuFixedFuncStruct.NodeClassType.ControlActuator)
                {
                    fixedFuncStructListRead.Add(ecuFixedFunc);
                }
            }

            return(fixedFuncStructListRead);
        }