Esempio n. 1
0
        public static PExpToshiba AnalyseProcess(MonFile File)
        {
            AnalyseResults result;
            PExpToshiba    process = new PExpToshiba();

            process.Date = File.StartTime;

            foreach (var step in File.Steps)
            {
                switch (step.stepnumber)
                {
                case 1:
                    //result = analyse_123(step);
                    process.InputData.V1 = null;
                    break;

                case 2:
                    result = analyse_123(step);

                    process.MachinaData.T_start_lower = result.TminLower;
                    process.MachinaData.T_start_upper = result.TminUpper;

                    process.MachinaData.Tv_lower = result.TmaxLower;
                    process.MachinaData.Tv_upper = result.TmaxUpper;

                    process.MachinaData.Gv_lower = result.TRateLower;
                    process.MachinaData.Gv_upper = result.TRateUpper;

                    process.MachinaData.Gv_lower_quali = result.TRateLowerQuality;
                    process.MachinaData.Gv_upper_quali = result.TRateUpperQuality;

                    process.InputData.Gv = Math.Round((((result.TUpper_Last + result.TLower_Last) / 2) - ((result.TUpper_First + result.TLower_First) / 2)) / result.Duration, 2);
                    process.InputData.Tv = ((result.TUpper_Last + result.TLower_Last) / 2);
                    process.InputData.Z1 = result.Posmax;

                    break;

                case 3:
                    result = analyse_123(step);
                    process.MachinaData.Tvu_lower = result.TminLower;
                    process.MachinaData.Tvu_upper = result.TminUpper;

                    process.MachinaData.T1u_lower = result.TmaxLower;
                    process.MachinaData.T1u_upper = result.TmaxUpper;

                    process.MachinaData.G1_lower = result.TRateLower;
                    process.MachinaData.G1_upper = result.TRateUpper;

                    process.MachinaData.G1_lower_quali = result.TRateLowerQuality;
                    process.MachinaData.G1_upper_quali = result.TRateUpperQuality;

                    process.InputData.G1  = Math.Round((((result.TUpper_Last + result.TLower_Last) / 2) - ((result.TUpper_First + result.TLower_First) / 2)) / result.Duration, 2);
                    process.InputData.Tvu = ((result.TUpper_First + result.TLower_First) / 2);
                    process.InputData.T1u = ((result.TUpper_Last + result.TLower_Last) / 2);

                    break;

                case 4:
                    result = analyse_4567(step);

                    process.MachinaData.T1_lower = result.TmaxLower;
                    process.MachinaData.T1_upper = result.TmaxUpper;
                    process.MachinaData.ST1      = result.Duration;

                    process.InputData.T1  = ((result.TUpper_Last + result.TLower_Last) / 2);
                    process.InputData.ST1 = result.Duration;

                    break;

                case 5:
                    result = analyse_4567(step);

                    process.MachinaData.T_press_av      = (result.TAverageUpper + result.TAverageLower) / 2;
                    process.MachinaData.T_press_G       = (result.TRateUpper + result.TRateLower) / 2;
                    process.MachinaData.T_press_G_quali = (result.TRateUpperQuality + result.TRateLowerQuality) / 2;

                    process.MachinaData.P1  = result.PAverage;
                    process.MachinaData.PT1 = result.PressTime;
                    process.MachinaData.ST2 = result.Duration;

                    process.InputData.P1  = Math.Round(result.PAverage, PressRound);
                    process.InputData.PT1 = result.PressTime;
                    process.InputData.ST2 = result.Duration;
                    process.InputData.V2  = null;
                    process.InputData.Z2  = result.Posmax;
                    break;

                case 6:
                    result = analyse_4567(step);

                    process.MachinaData.P2  = result.PAverage;
                    process.MachinaData.PT1 = result.PressTime;

                    process.MachinaData.G3_lower = result.TRateLower;
                    process.MachinaData.G3_upper = result.TRateUpper;

                    process.MachinaData.G3_lower_quali = result.TRateLowerQuality;
                    process.MachinaData.G3_upper_quali = result.TRateUpperQuality;

                    process.MachinaData.T2_lower = result.TChangeLower;
                    process.MachinaData.T2_upper = result.TChangeUpper;

                    process.InputData.G2 = Math.Round((((result.TUpper_Last + result.TLower_Last) / 2) - ((result.TUpper_First + result.TLower_First) / 2)) / result.Duration, 2);
                    process.InputData.T2 = (result.TChangeLower + result.TChangeUpper) / 2;
                    process.InputData.P2 = Math.Round(result.PAverage, PressRound);

                    break;

                case 7:
                    result = analyse_7(step);
                    process.MachinaData.T5_lower = result.TminLower;
                    process.MachinaData.T5_upper = result.TminUpper;

                    process.MachinaData.T3_lower = result.TmaxLower;
                    process.MachinaData.T3_upper = result.TmaxLower;

                    process.MachinaData.T4_lower = result.TChangeLower;
                    process.MachinaData.T4_upper = result.TChangeUpper;

                    process.MachinaData.G4_lower = result.TRateLower;
                    process.MachinaData.G4_upper = result.TRateUpper;

                    process.MachinaData.G4_lower_quali = result.TRateLowerQuality;
                    process.MachinaData.G4_upper_quali = result.TRateUpperQuality;

                    process.MachinaData.P3 = result.PAverage;

                    process.InputData.T3 = (result.TLower_First + result.TUpper_First) / 2;
                    process.InputData.T4 = (result.TChangeUpper + result.TChangeLower) / 2;
                    process.InputData.T5 = (result.TLower_Last + result.TUpper_Last) / 2;

                    process.InputData.P3 = Math.Round(result.PAverage, 2);

                    break;
                }

                if (process.InputData.Tvu == null)
                {
                    process.InputData.Tvu = process.InputData.Tv;
                }
            }



            return(process);
        }
Esempio n. 2
0
        public static MonFile getMonFileData(string path)
        {
            List <string> m_data = new List <string>();

            using (StreamReader reader = new StreamReader(path))
            {
                while (!reader.EndOfStream)
                {
                    m_data.Add(reader.ReadLine());
                }
            }

            MonFile m_file = new MonFile();
            string  valueString;

            m_file.Path = path;

            valueString      = m_data.Find(item => item.Contains("StartTime"));
            valueString      = valueString.Remove(0, valueString.IndexOf(',') + 1);
            m_file.StartTime = Convert.ToDateTime(valueString);

            valueString     = m_data.Find(item => item.Contains("StopTime"));
            valueString     = valueString.Remove(0, valueString.IndexOf(',') + 1);
            m_file.StopTime = Convert.ToDateTime(valueString);

            m_file.CycleTime = m_file.StopTime - m_file.StartTime;

            int dataIndex = m_data.FindIndex(item => item.Contains("SeqNo")) + 1;

            int _stepIndex        = 0;      //stepIndex
            int _currentListIndex = -1;     //ListIndex of steplist

            for (int i = dataIndex; i < m_data.Count; i++)
            {
                //separate data from string
                string[] parameters = m_data[i].Split(',');

                //identify current step
                int currentStep = Convert.ToInt32(parameters[14]);
                if (currentStep != _stepIndex)
                {
                    _stepIndex = currentStep;
                    m_file.Steps.Add(new MonFile.ProcessStep(currentStep));
                    _currentListIndex = m_file.Steps.Count - 1;
                }

                //fill step with parameter data
                MonFile.ProcessStep.MeasuringPoint _mp = new MonFile.ProcessStep.MeasuringPoint();

                _mp.SequenceNumber = Convert.ToInt32(parameters[0]);
                _mp.TimePass       = Convert.ToInt32(parameters[1]);
                _mp.LTemp1         = Convert.ToDouble(parameters[2].Replace('.', ','));
                _mp.UTemp1         = Convert.ToDouble(parameters[3].Replace('.', ','));
                _mp.PressZ         = Convert.ToDouble(parameters[4].Replace('.', ','));
                _mp.PosZ           = Convert.ToDouble(parameters[5].Replace('.', ','));
                _mp.LTemp2         = Convert.ToDouble(parameters[6].Replace('.', ','));
                _mp.UTemp2         = Convert.ToDouble(parameters[7].Replace('.', ','));
                _mp.PressW         = Convert.ToDouble(parameters[8].Replace('.', ','));
                _mp.PosW           = Convert.ToDouble(parameters[9].Replace('.', ','));
                _mp.Temp5          = Convert.ToDouble(parameters[10].Replace('.', ','));
                _mp.Temp6          = Convert.ToDouble(parameters[11].Replace('.', ','));
                _mp.Temp7          = Convert.ToDouble(parameters[12].Replace('.', ','));
                _mp.Temp8          = Convert.ToDouble(parameters[13].Replace('.', ','));
                _mp.StepNumber     = Convert.ToInt32(parameters[14]);

                _mp.ChangePosZ     = Convert.ToDouble(parameters[15].Replace('.', ','));
                _mp.CHangePressZ   = Convert.ToDouble(parameters[16].Replace('.', ','));
                _mp.MarkerFlag     = parameters[17];
                _mp.UserFlag       = parameters[18];
                _mp.AlarmCode1     = parameters[19];
                _mp.AlarmCode2     = parameters[20];
                _mp.AlarmCode3     = parameters[21];
                _mp.AlarmCode4     = parameters[22];
                _mp.AlarmCode5     = parameters[23];
                _mp.SelfAlarmCode1 = parameters[24];
                _mp.SelfAlarmCode2 = parameters[25];
                _mp.SelfAlarmCode3 = parameters[26];
                _mp.SelfAlarmCode4 = parameters[27];
                _mp.SelfAlarmCode5 = parameters[28];

                m_file.Steps[_currentListIndex].MeasuringPoints.Add(_mp);
            }

            return(m_file);
        }