清洗机获取采集数据

schangxiang@126.com

2024-08-18 a3e2b38a895b32ac08bb4acf18a4e57f65651c4a

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/WorkPieceInfoManager.cs

@@ -182,7 +182,7 @@
                            }
                            else
                            {
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
@@ -226,7 +226,16 @@
                        WorkPieceProcess process = new WorkPieceProcess();
                        process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
                        process.StartTime = DateTimeHelper.GetDateTime();
                        process.QualityState = info.QualityState.HasValue ? info.QualityState.Value : (int)QualityState.OK;

                        //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                        //process.QualityState = info.QualityState.HasValue ? info.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                        process.QualityState = GetQualityStateValue(info.QualityState);

                        if (process.WorkingProcedureCurrent == WorkingProcedureForHMI.OP70.ToString())
                        { //特殊处理OP70，因为OP70没有测量，默认合格 [Editby shaocx,2024-07-03]
                            process.QualityState = (int)QualityState.OK;//默认合格，OP70默认是合格
                        }

                        process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                        process.CreatedUserName = loginfo.MonitoringPoint;
                        process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
@@ -490,12 +499,12 @@
                                }
                                else
                                {
                                    pieceInfo.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                    pieceInfo.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                    pieceInfo.Remarks = "OP05新增工件信息";
                                }
                                pieceInfo.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                                pieceInfo.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                                pieceInfo.CreatedUserName = logMiddle.MonitoringPoint;
                                pieceInfo.CreatedUserName = ResetUpdatedUserName(logMiddle);
                                pieceInfo.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                                pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();//
                                pieceInfo.WorkingProcedureEndTime = null;
@@ -540,7 +549,7 @@
                            else
                            {//更新工件
                                equinfo.WorkPieceID = logMiddle.WorkPieceID;
                                equinfo.UpdatedUserName = logMiddle.MonitoringPoint;
                                equinfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                                equinfo.UpdatedTime = DateTime.Now;
                                equinfo.OnlineTime = DateTime.Now;
                            }
@@ -558,7 +567,7 @@
                        pieceInfo.QualityStateUpdateTime = logMiddle.UpdatedTime.Value.LocalDateTime;
                        pieceInfo.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                        pieceInfo.Remarks = pieceInfo.Remarks ?? "" + $"{logMiddle.WorkingProcedure}质量检测完成修改";
                        pieceInfo.UpdatedUserName = logMiddle.MonitoringPoint;
                        pieceInfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                        pieceInfo.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        if (!(pieceInfo.WorkingProcedureStartTime.HasValue && pieceInfo.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                        {//工序开始时间没有则赋值
@@ -714,15 +723,20 @@
                            WorkPieceProcess process = new WorkPieceProcess();
                            process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(pieceInfo);
                            process.StartTime = DateTimeHelper.GetDateTime();
                            process.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.QualityState.Value : (int)QualityState.OK;

                            //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                            //process.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                            process.QualityState = WorkPieceInfoManager.GetQualityStateValue(pieceInfo.QualityState);


                            //记录质量不合格原因 【Editby shaocx,2024-06-26】
                            //赋值不合格原因
                            SetQualityNoOk_WorkPieceProcess(logMiddle, ref process);

                            process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            process.CreatedUserName = logMiddle.MonitoringPoint;
                            process.CreatedUserName = ResetUpdatedUserName(logMiddle);
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.UpdatedUserName = logMiddle.MonitoringPoint;
                            process.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                            process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.OperationType = OperationType.生产.ToString();
                            process.QualityDataInfoID = qualityData.Id;
@@ -732,16 +746,20 @@
                        else
                        {//其他的都只是修改
                            pro.QualityDataInfoID = qualityData.Id;
                            pro.UpdatedUserName = logMiddle.MonitoringPoint;
                            pro.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                            pro.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.QualityState.Value : 9;

                            //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                            //pro.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.QualityState.Value : 9;
                            pro.QualityState = WorkPieceInfoManager.GetQualityStateValue(pieceInfo.QualityState);

                            //赋值不合格原因
                            SetQualityNoOk_WorkPieceProcess(logMiddle, ref pro);

                            //TODO:判断如果是60工序，那么就要更新pro表的创建人为loginfo.MonitoringPoint 【Editby shaocx,2024-06-05】
                            if (logMiddle.WorkingProcedure == "OP60")
                            {
                                pro.CreatedUserName = logMiddle.MonitoringPoint;
                                pro.CreatedUserName = ResetUpdatedUserName(logMiddle);

                            }
                        }
@@ -784,6 +802,88 @@
                }
            }
        }

        /// <summary>
        /// 质量检测完成-OP70专用
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <param name="type"></param>
        public static void QualityInfoCompleteForOP70(WorkPieceLogMiddle logMiddle, LogType type)
        {
            if (string.IsNullOrEmpty(logMiddle.QualityOP70To1) && string.IsNullOrEmpty(logMiddle.QualityOP70To2) && string.IsNullOrEmpty(logMiddle.QualityOP70To3))
            {
                Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控清洗机数据 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]获取的三个值都是空的，不处理返回");
                return;
            }
            using (DbModel db = new DbModel())
            {
                try
                {
                    bool isAdd = false;
                    if (logMiddle.WorkPieceID.Length == 22)
                    {
                        var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                        if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
                        {//插入QualityDataInfo表
                            isAdd = true;
                            qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                        }

                        qualityData.QualityStateUpdateUser = "OP7009";
                        qualityData.QualityReceiveTime = DateTime.Now;

                        //特殊处理OP70的质量数据
                        if (!string.IsNullOrEmpty(logMiddle.QualityOP70To1) && !string.IsNullOrEmpty(qualityData.QualityOP70To1))
                        {
                            qualityData.QualityOP70To1 = logMiddle.QualityOP70To1;
                        }
                        if (!string.IsNullOrEmpty(logMiddle.QualityOP70To2) && !string.IsNullOrEmpty(qualityData.QualityOP70To2))
                        {
                            qualityData.QualityOP70To2 = logMiddle.QualityOP70To2;
                        }
                        if (!string.IsNullOrEmpty(logMiddle.QualityOP70To3) && !string.IsNullOrEmpty(qualityData.QualityOP70To3))
                        {
                            qualityData.QualityOP70To3 = logMiddle.QualityOP70To3;
                        }

                        db.QualityDataInfoLog.Add(GetAddQualityDataInfoLog(qualityData));//插入日志

                        if (isAdd)
                        {
                            db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
                        }
                        db.SaveChanges();//保存数据
                    }
                    else
                    {
                        Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控清洗机数据 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception ex)
                {
                    Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控清洗机数据 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：", ex);
                }
                finally
                {
                }
            }
        }

        /// <summary>
        /// 赋值 修改人 【Editby shaocx,2024-07-05】
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <returns></returns>
        public static string ResetUpdatedUserName(WorkPieceLogMiddle logMiddle)
        {
            if (logMiddle.MonitoringPoint.Equals("OP1003"))
            {//因为OP10和OP40是一台机器，OP1003专门是OP40测量的。
                return "OP4003";
            }
            return logMiddle.MonitoringPoint;
        }

        /// <summary>
        /// 工件推出NOOK
        /// </summary>
@@ -1026,7 +1126,7 @@
                            }
                            else
                            {
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();//WorkPieceInitOnlineTime
@@ -1153,7 +1253,9 @@
                            }
                            else
                            {
                                process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;
                                //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                                //process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                                process.QualityState = WorkPieceInfoManager.GetQualityStateValue(logMiddle.QualityState);
                            }
                            process.CreatedUserName = logMiddle.MonitoringPoint;
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
@@ -2146,13 +2248,47 @@

        public static void SetQualityNoOk_WorkPieceInfo(WorkPieceLogMiddle logMiddle, ref WorkPieceInfo pieceInfo)
        {
            if (!IsWirteQualityNoOk(logMiddle, pieceInfo.QualityNoOk)) return;

            pieceInfo.QualityNoOk = logMiddle.QualityNoOk;
            pieceInfo.QualityNoOkReason = logMiddle.QualityNoOkReason;
        }
        public static void SetQualityNoOk_WorkPieceProcess(WorkPieceLogMiddle logMiddle, ref WorkPieceProcess pieceProcess)
        {
            if (!IsWirteQualityNoOk(logMiddle, pieceProcess.QualityNoOk)) return;

            pieceProcess.QualityNoOk = logMiddle.QualityNoOk;
            pieceProcess.QualityNoOkReason = logMiddle.QualityNoOkReason;
        }

        /// <summary>
        /// 是否需要重写 NOOK原因
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <param name="pieceInfo"></param>
        /// <returns></returns>
        public static bool IsWirteQualityNoOk(WorkPieceLogMiddle logMiddle, int? qualityNoOk)
        {
            if (logMiddle.WorkingProcedure == (WorkingProcedureForHMI.OP30).ToString())
            {
                //特殊逻辑：按照OP30的顺序判断
                if (logMiddle.QualityNoOk != null && qualityNoOk != null
                    && (
                      qualityNoOk == (int)QualityNoOkEnum.OP30压衬套工位力矩大
                      || qualityNoOk == (int)QualityNoOkEnum.OP30涨断工位力矩大
                      || qualityNoOk == (int)QualityNoOkEnum.OP30终拧紧工位力矩大
                      || qualityNoOk == (int)QualityNoOkEnum.OP30预拧紧工位力矩大
                    )
                    )
                {
                    if ((int)logMiddle.QualityNoOk > (int)qualityNoOk)
                    {//不需要重新赋值
                        return false;
                    }
                }
            }

            return true;
        }


@@ -2234,15 +2370,35 @@
            return loginfo;
        }

        /// <summary>
        /// 设置中间变量的质量数据
        /// </summary>
        /// <param name="logMiddle"></param>
        public static void SetLogMiddleForQuality(ref WorkPieceLogMiddle logMiddle)
        {

            logMiddle.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") || logMiddle.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);

            //根据质量数据判断是否合格/不合格 【Editby shaocx,2024-06-25】
            QualityNoOkEnum? qualityNoOkEnum = null;
            QualityState qualityState = WorkPieceInfoManager.CalcQualityStateForOP(logMiddle, ref qualityNoOkEnum);
            logMiddle.QualityState = (int)qualityState;
            logMiddle.QualityStateStr = qualityState.ToString();
            if (qualityNoOkEnum != null)
            {
                logMiddle.QualityNoOk = (int)qualityNoOkEnum;
                logMiddle.QualityNoOkReason = qualityNoOkEnum.ToString();
            }
        }

        /// <summary>
        /// 计算OP 质量数据是否合格
        /// </summary>
        public static QualityState CalcQualityStateForOP(WorkPieceLogMiddle logMiddle, ref QualityNoOkEnum? qualityNoOkEnum)
        private static QualityState CalcQualityStateForOP(WorkPieceLogMiddle logMiddle, ref QualityNoOkEnum? qualityNoOkEnum)
        {
            QualityState qualityState = QualityState.Suspected;
            if (logMiddle.WorkingProcedure == "OP60")
            {
            {//合格/不合格由 WMS自行判断
                decimal _QualityOP60To1 = SystemHelper.GetDecimal(logMiddle.QualityOP60To1);
                decimal _QualityOP60To2 = SystemHelper.GetDecimal(logMiddle.QualityOP60To2);
                var isPass_QualityOP60To1 = false;
@@ -2281,8 +2437,14 @@
                }
                return qualityState;
            }
            if (logMiddle.WorkingProcedure == "OP80")
            {
            else if (logMiddle.WorkingProcedure == "OP80")
            {//合格/不合格由 OP80 判断，QualityState 和 QualityStateStr 都在调用当前方法前 写入值了
                if (logMiddle.QualityState == (int)QualityState.OK)
                {
                    qualityState = QualityState.OK;
                    return qualityState;
                }

                decimal _QualityOP80_D_TKZJ = SystemHelper.GetDecimal(logMiddle.QualityOP80_D_TKZJ);
                if (!(_QualityOP80_D_TKZJ >= (decimal)53.018 && _QualityOP80_D_TKZJ <= (decimal)53.03))
                {
@@ -2320,13 +2482,13 @@
                }

                decimal _QualityOP80To4 = SystemHelper.GetDecimal(logMiddle.QualityOP80To4);
                if (!(_QualityOP80To4 >= (decimal)0 && _QualityOP80To4 <= (decimal)0.075))
                if (!(_QualityOP80To4 >= (decimal)(-0.075) && _QualityOP80To4 <= (decimal)0.075))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头孔平行度弯曲超差;
                }

                decimal _QualityOP80To5 = SystemHelper.GetDecimal(logMiddle.QualityOP80To5);
                if (!(_QualityOP80To5 >= (decimal)0 && _QualityOP80To5 <= (decimal)0.2))
                if (!(_QualityOP80To5 >= (decimal)(-0.2) && _QualityOP80To5 <= (decimal)0.2))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头孔平行度扭曲超差;
                }
@@ -2365,41 +2527,92 @@
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP10")
            {
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP10厚度超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP20")
            {
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP20小头孔直径超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP30")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityStateStr.Equals("OK"))
                {
                    qualityState = QualityState.OK;
                }
                else
                {
                    qualityState = QualityState.NG;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP35")
            {
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP35滚压力不合格;
                }
                else
                {
                    qualityState = QualityState.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP40")
            {
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP40厚度超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                }
                return qualityState;
            }
            return qualityState;
        }


        /// <summary>
        /// 获取质量状态值
        /// </summary>
        /// <param name="qualityState"></param>
        /// <returns></returns>
        public static int GetQualityStateValue(int? qualityState)
        {
            if (qualityState.HasValue == false)
            {
                return (int)QualityState.Suspected;
            }
            if (qualityState.Value == 1)
            {
                return (int)QualityState.OK;
            }
            if (qualityState.Value == 2)
            {
                return (int)QualityState.NG;
            }
            return (int)QualityState.Suspected;
        }


        #endregion
    }
}