meswork/14-PingZhi1550KV-MesProject
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: 初始化平芝550kVMesProject项目

Browse Source
This commit is contained in:
yexingqiang
2026-06-08 15:50:43 +08:00
commit 63fdadbb4d
1370 changed files with 182804 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
Common/09MesDataFunction/MesDataFunction/MisDataFunction/Heartbeat.cs Normal file
View File

@@ -0,0 +1,25 @@
//using bizFacade;
using System;
using System.Collections;
using System.Data;
//using SystemFramework;
namespace MisDataFunction
{
partial class Function
{
private static void Heartbeat(string opName, string tagValue)
{
if (tagValue == "1")
{
Write_TagTypeID(15, opName, true);
}
else
{
Write_TagTypeID(15, opName, false);
}
}
}
}

326
Common/09MesDataFunction/MesDataFunction/MisDataFunction/MIS.Interface.cs Normal file
View File

@@ -0,0 +1,326 @@
using bizFacade;
using DoWhatPlc;
using MesServerWork;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//using SystemFramework;
namespace MisDataFunction
{
public partial class Function: MIS_BASE
{
///<summary>
/// 处理MIS逻辑 TagName 变量类型代码 变量类型名称
/// WorkStart 2 工件到位。托盘到达工位，并且托盘上有工件。
///RepairPartStatusPLC 3 备用
///RepairPathString 4 工位返修字符串（121211112222111）,前2位是西门子字符串格式，第一位是总长度，第二位是实际长度
///EngineTypeGetOverMES 5 MES传递总成信息给PLC（上线工位）
///PartPalletGoOver 6 上线工位。0：正常工作；1：空托盘放行，PLC读取到此标志不走申请上线逻辑。
///MaterialVerifyOver 7 MES保存完质量数据，物料数据等与PLC信号交互完成后通知PLC，所以工步都完成，才可以放行工件，正常工作时工件放行的必要条件。
///FalseGo 8 按MES界面[不合格放行] 按钮，MES发送此信号。操作者判断工件不合格，通知设备，按不合格方式放行工件，工件流转到返修下线工位后，返修下线。MES工作完成MES0.3=1，MES合格放行MES0.5=0，MES0.4=1
///EngineTypeID 9 MES发动机机型标志(必须PLC)
///EngineID 10 MES发动机编号(必须PLC)
///EngineType 11 MES发动机机型(必须PLC)
///PartPalletStatus 13 MES激发变量托盘到位离开(必须PLC)
///HeartBeatPLC 14 心跳处理：PLC收到MES心跳信号后，PLC延时5秒后，数值取反再写回PLC，写回PLC开始计时，如果5秒钟MES无反馈报通讯故障。
///HeartBeatMIS 15 间隔时间5S，心跳处理。收到PLC心跳信号后，MES按原值回写。PLC收到MES信号后延时5秒，取反写入，以此循环。
///TargetTimeRead 16 MES允许可读工位运行时间
///MachineTargetTime 17 目标运行时间
///MachineActualTime 18 实际运行时间
///MesRead 19 质量数据可以读数据
///MesReadOver 20 MES保存完数据(必须MIS)
///QualityMask 21 质量数据工位合格标志0:没有工作；1：合格 ；2 ：不合格(必须PLC)
///PalletInfo 22 0空托盘，1合格件，2不合格件
///RepairStatusPLC 23 0正常件，1返修件
///Reserved_3 24 备用
///Reserved_4 25 备用
///Reserved_5 26 备用
///Reserved_6 27 备用
///Reserved_7 28 备用
///Reserved_8 29 备用
///Reserved_9 30 备用
///Reserved_10 31 备用
///Reserved_11 32 备用
///Reserved_12 33 备用
///Reserved_13 34 备用
///Reserved_14 35 备用
///PLCSPareint1 36 备用
///PLCSPareint2 37 备用
///PLCSPareint3 38 备用
///PLCSarestring1 39 备用
///PLCSarestring2 40 备用
///MarkID 42 机体打标号（MES）前2位是西门子字符串格式，第一位是总长度，第二位是实际长度
///PartLoad 43 上线工位，PLC向MES申请总成编号。收到该信号后，MES将机型标志（DBB22 ~23）、总成号（DBB24 ~63）、总成机型DBB64 ~103写入PLC。之后MES通过信号“传递机型（DBX0.1）”通知PLC。
///EngineTypeGetOverPLC 44 PLC将机型标志（DBB50…51）、工件编号（DBB52…101）、产品型号（DBB102…187）、托盘编号（DBB188…189）准备完毕后，通知MES。
///PartLoadOK 48 备用
///Reserved_18 49 备用
///PalletDown 50 暂时保留，项目未使用
///ConfirmOkGo 51 按MES界面[合格放行] 按钮，MES发送此信号。操作者判断工件合格，通知设备，工件按合格方式放行工件。MES工作完成MES0.3=1，MES合格放行MES0.5=1，MES0.4=0
///ResetDevice 52 针对手动工位，无HMI，需要复位设备在MES页面操作。
///UnloadCompleted 53 暂时保留，项目未使用
///MachineTime_ReadOver 54 备用
///Reserved_19 58 备用
///FixOK 59 手动拧紧工位，单工步螺栓拧紧完成，通知PC读取数据。
///Reserved_21 61 备用
///Reserved_22 62 备用
///Reserved_23 63 备用
///Reserved_24 64 备用
///Reserved_25 65 备用
///FixAllow 66 设备工作的必须信号,对于有物料验证的工位，MES验证完成给出此信号，对于无物料验证工位，MES直接给出此信号。
///FixOver 67 用于手动拧紧且有质量数据工位。通知设备当前工步拧紧螺钉工作结束。
///MatchingCompleted 68 分线上总线，匹配成功是1；不成功是0。
///Match 69 分线上总线，匹配成功是1；不成功是0。
///Reserved_2 70 备用
///IsAutoGetEngineID 71 自动手动申请工件编号。0是自动方式；1：手动方式。暂时保留，生成流水号方式是在数据库中实现的
///RepairUplineMES 72 上线清空MOBY（针对上线工位）：通知PLC从新开始申请上线流程
///EngineTypeID_MES 73 MES发动机机型标志(必须MES)
///EngineID_MES 74 MES发动机编号(必须MES)
///EngineType_MES 75 MES发动机机型(必须MES)
///Reserved_20 76 备用
///ProcessCode 77 手动拧紧工位：由MES通知PLC拧紧序号
///OnLineState 79 通过线体工位PC实现下达工位工作状态：工位有三种状态：在线、离线、屏蔽。在线：0正常状态，实现正常功能。1离线:设备脱离MES工作，进入不交互模式。
///PartPalletCode 80 托盘编号(B5A)
///BoltCode 88 手动拧紧工位：指导PLC所用套筒
///RepairStatus 93 0正常件，1返修件。对于上线工位MES给出是正常上线还是返修上线,返修路径
///Reserved_15 110 备用
///Reserved_16 111 备用
///Reserved_17 112 备用
///SPareint1 113 备用int1
///SPareint2 114 备用int2
///SPareint3 115 备用int3
///Sparestring1 116 备用字符串1
///Sparestring2 117 备用字符串2
///MachineStatusPutOn 1000 机床上电(必须PLC)
///MachineStatusWorkOn 1001 循环开始(必须PLC)
///MachineStatusAlarm 1002 机床故障(必须PLC)
///MachineStatusNoPart 1003 上料无件(必须PLC)
///MachineStatusBlock 1004 下料堵塞(必须PLC)
///Alarm 103 设备报警
/// </summary>
/// <param name = "e" ></ param >
public static void MIS_Funtion(object e)
{
try
{
string recData = e.ToString();
string[] dataArray = recData.Split('|');
if (dataArray.Length != 4)
return;
//消息来源
string m_Source = dataArray[0].ToString();
//消息类型
string m_Command = dataArray[1].ToString();
//工位号
string m_OpName = dataArray[2].ToString();
//消息参数
string m_Value = dataArray[3].ToString();
DoWhatPlc.ReturnValueString rv = Newtonsoft.Json.JsonConvert.DeserializeObject<DoWhatPlc.ReturnValueString>(m_Value);
//Console.WriteLine($"【【{rv.TagID}【【【【{ rv.TagKeepTime}");
int tagType;
string opName;
string tagValue;
int tagid;
DoWhatPlc.ReturnValueString msgEvent = rv;
if (msgEvent.TagValue == null) return;
tagType = Convert.ToInt32(msgEvent.TagTypeID);
opName = msgEvent.OpName.ToString();
tagid = Convert.ToInt32(msgEvent.TagID);
//int tagType;
//string opName;
//string tagValue;
//int tagid;
//DoWhatPlc.CustomeEvetnArgs msgEvent = (DoWhatPlc.CustomeEvetnArgs)e;
//if (msgEvent.TagValue == null) return;
//tagType = Convert.ToInt32(msgEvent.TagType);
//opName = msgEvent.OpName.ToString();
//tagid = Convert.ToInt32(msgEvent.TagKey);
switch (Convert.ToInt32(msgEvent.TagTypeCodeID))
{
case 11:
switch (msgEvent.TagValue.ToLower())
{
case "1":
case "true":
tagValue = "1";
break;
default:
tagValue = "0";
break;
}
break;
default:
tagValue = msgEvent.TagValue.ToString();
break;
}
///根据信号处理逻辑
switch (tagType)
{
case 19:
//允许保存
MesRead(opName, tagValue, tagid);
break;
case 14:
//心跳
Heartbeat(opName, tagValue);
break;
case 44://PLC传递机型过后 才允许保存过站信息，否则不允许保存
//if (tagValue == "1")
//{
// IsEngTypeGetOver_Write(opName, true);
// EngineData Enginedata = new EngineData(DtWebApi.ReadWritePLC.ReadPLC("10", opName).ToString(), Convert.ToInt32(DtWebApi.ReadWritePLC.ReadPLC("80", opName)));
// //EngineData Enginedata = new EngineData(MesDataFunction.OpcOperation.ReadPLC(10, opName).ToString(), Convert.ToInt32(MesDataFunction.OpcOperation.ReadPLC(80, opName)));
// //保存产品编号、托盘号 保存过站信息用
// EngineData_Hash_Write(opName, Enginedata);
//}
break;
case 2://工件到位
WorkStart( rv);
//WorkStart(opName, tagValue);
break;
case 51:
if (hashtableOpName_IsHaveComputer[opName].ToString() == "1")
{
SaveProductLeaveData(opName, 1);
}
break;
case 8:
if (hashtableOpName_IsHaveComputer[opName].ToString() == "1")
{
SaveProductLeaveData(opName, 2);
}
break;
case 103:
Alarm_Insert(rv);
break;
}
}
catch (Exception err)
{
////ApplicationLog.WriteLog(err, err.Message);
}
}
private static void Alarm_Insert(ReturnValueString rv)
{
string TagID;
string opName;
string tagTypeID;
int TagValue;
DateTime alarmStartTime;
DateTime alarmEndTime;
int TimeDiff;
string TagOrderBy;
string Text1;
string Text2;
TagID = rv.TagID;
tagTypeID = rv.TagTypeID;
opName = rv.OpName;
TagValue = Convert.ToInt32( rv.TagValue);
alarmStartTime = Convert.ToDateTime( rv.TimeStampBefore);
alarmEndTime = Convert.ToDateTime( rv.TimeStamp);
TimeDiff = Convert.ToInt32(rv.TagKeepTime);
TagOrderBy = rv.TagOrderBy;
Text1 = rv.ItemName;
Text2 = rv.ShaftID;
BaseDataSystemMES.Alarm_Insert(TagID, tagTypeID, opName, TagValue,
alarmStartTime, alarmEndTime, TimeDiff, Text1, Text2, TagOrderBy);
}
private static void WorkStart(ReturnValueString rv)
{
var ro = rv.ReturnValueToObject();
string opName = ro.OpName;
DateTime arrivedTime = ro.TimeStampBefore;
DateTime leavedTime = ro.TimeStamp;
int TimeDiff = ro.TagKeepTime;
int targetTime = 0;
string isPass = "";
int QualityMark=0;
string tagValue="0";
switch (ro.TagValue.ToString().ToLower())
{
case "1":
case "true":
tagValue = "1";
break;
default:
tagValue = "0";
break;
}
//if (ro.TagValue.ToString() == "0")
//{
// //Write_TagTypeID(5, opName, false);//MES传递机型
// //Write_TagTypeID(66, opName, false);//允许工作
// //Write_TagTypeID(51, opName, false);//合格放行
// //Write_TagTypeID(8, opName, false);//不合格放行
// //Write_TagTypeID(7, opName, false);//工作完成
// //Write_TagTypeID(20, opName, false);//保存完成
// //string isHaveComputer = hashtableOpName_IsHaveComputer[opName].ToString();
// //if (Convert.ToInt32(isHaveComputer) == 0)//自动工位 读合格标志
// //{
// // if (IsEngTypeGetOver_Read(opName))
// // {
// // //PLC未传递机型 不保存过站信息
// // SaveProductLeaveData_AutoWorkStation(opName, Convert.ToInt32(DtWebApi.ReadWritePLC.ReadPLC("21", opName)));
// // //SaveProductLeaveData_AutoWorkStation(opName, Convert.ToInt32(MesDataFunction.OpcOperation.ReadPLC(21, opName)));
// // }
// //}
// ////清空信号
// ////m_WorkStart_OpName[opName] = 0;//清空工件到位标志
// ////通知WEB更新产量
// //SendActuallyCount(opName, 0);
//}
QualityMark = Convert.ToInt32(ReadPLC(21, opName));
if (QualityMark == 1)
{
isPass = "1";
}
else
{
isPass = "0";
}
int EngineTypeID;//机型代码
int PartPallet_Code;//托盘编号
string EngineType;//机型
string EngineID;//工件编号
string OrderForm;
MIS_BASE.GetEngineTypeFromPLC(opName, out EngineTypeID, out EngineType, out EngineID, out PartPallet_Code,out OrderForm);
//EngineData Enginedata = (EngineData)EngineData_Hash_Read(opName);
BaseDataSystemMES.WorkStartInsert_AutoWorkStation(opName, EngineID, PartPallet_Code, arrivedTime, leavedTime, TimeDiff, targetTime, null, isPass, 0);
}
}
}

465
Common/09MesDataFunction/MesDataFunction/MisDataFunction/MesRead.cs Normal file
View File

@@ -0,0 +1,465 @@
//using BasicData;
using bizFacade;
using DoWhatPlc;
using Newtonsoft.Json;
//using bizFacade;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
//using SystemFramework;
namespace MisDataFunction
{
partial class Function
{
/// <summary>
/// 获取质量数据Hashtable
/// </summary>
/// <param name="opName"></param>
/// <returns></returns>
//static public Hashtable ReadPLC_Sync_DataList_MesRead(string opName)
//{
// return (Hashtable)MesDataFunction.OpcOperation.ReadPLC_Sync_DataList_MesRead(opName);
//}
static object lockerReadPLC_Sync_DataList_MesRead1 = new object();
public static void ReadPLC_Sync_DataList_MesRead(string opName, out Hashtable valueList, out DataTable BasicDataTagValue, out DataTable BasicDataTagValueUpDown, out Hashtable hashtable_EngineTypeID, out Hashtable hashtable_tagTable_OpName_SaveData)
{
//QualityDataSaveList QualityDataType
valueList = new Hashtable();
//var qualityDataSaveList = DtWebApi.SaveData.ReadPLC_Sync_DataList_MesRead(opName);
var qualityDataSaveList = MesServerWork.MIS_BASE.ReadPLC_Sync_DataList_MesRead(opName);
foreach (DictionaryEntry de in qualityDataSaveList.valuList)
{
valueList.Add(de.Key, JsonConvert.DeserializeObject<QualityDataType>(de.Value.ToString()));
}
BasicDataTagValue = qualityDataSaveList.BasicDataTagValue;
BasicDataTagValueUpDown = qualityDataSaveList.BasicDataTagValueUpDown;
hashtable_EngineTypeID = qualityDataSaveList.hashtable_EngineTypeID;
hashtable_tagTable_OpName_SaveData = qualityDataSaveList.hashtable_tagTable_OpName_SaveData;
}
public static Hashtable ReadPLC_Sync_DataList_MesRead(string opName)
{
lock (lockerReadPLC_Sync_DataList_MesRead1)
{
Hashtable ht = new Hashtable();
var cd = ReadPLC_GroupData(opName);
//var cd = PlcLinkForm.ReadPLC_GroupData(opName);
foreach (var _cd in cd)
{
var tagID = Convert.ToInt32(_cd.TagID);
var TF =_cd.TF;
QualityDataType qualityDataType;
qualityDataType = new QualityDataType();
qualityDataType.tagID = TF.TagID;
qualityDataType.tagTypeID = TF.TagTypeID;//变量类型
qualityDataType.opName = opName;
qualityDataType.isGoodBad = 192;
int.TryParse(TF.TagQuality, out int TagQuality);
qualityDataType.tagQuality = TagQuality;
qualityDataType.tagValueType = TF.TagTypeCodeID;
int.TryParse(TF.TagOrderBy, out int TagOrderBy);
qualityDataType.tagOrderBy = TagOrderBy;
int.TryParse(TF.TagItemOrderBy, out int TagItemOrderBy);
qualityDataType.tagItemOrderBy = TagItemOrderBy;
qualityDataType.tagProperty = TF.TagProperty;//变量特点
qualityDataType.tagValue = TF.TagValue;//变量值
ht.Add(tagID, qualityDataType);
}
return ht;
}
}
/// <summary>
/// 允许保存(针对半自动和手动压装工位)
/// </summary>
/// <param name="OpName"></param>
/// <param name="tagValue"></param>
private static void MesRead(string opName, string tagValue, int tagid)
{
if (tagValue == "0")
{
Write_TagTypeID(20, opName, false);
}
else
{
SaveQualityData(opName, Convert.ToInt32(tagValue), tagid);
}
}
private static void SaveQualityData(string opName, int tagValue, int tagID)
{
try
{
int id_tagCF;
int qualityMask = 0;
int engineTypeID = 0;
string engineID = "";
string engineType = "";
string engineTraceCode = "";
string engineCap = "";
string partPallet = "";
DataTable dt_WWW;
dt_WWW = BaseDataSystemMES.BuildDataTables_WWW();
Hashtable valueList;
//valueList = ReadPLC_Sync_DataList_MesRead(opName);
ReadPLC_Sync_DataList_MesRead(opName, out valueList, out BasicDataTagValue, out BasicDataTagValueUpDown, out hashtable_EngineTypeID, out hashtable_tagTable_OpName_SaveData);
valueList = GetQualityData_GoodBad_Values(valueList);
int mes_MustTest = 0;
int onLineState = 0;
int partMoveDirection = 0;
int pressIsOK = 0;
int pressIsNoOK = 0;
BaseDataSystemMES.GetQualityDataTable_B5A(valueList, opName, BasicDataTagValue,
BasicDataTagValueUpDown,
out dt_WWW,//数据列表
out qualityMask,//工位合格标志
out engineTypeID,//发动机类型代码
out engineID,//发动机编号
out engineType, //发动机型号
out partPallet,//托盘编号
out engineTraceCode, //发动机条码
out engineCap,//缸盖号,
hashtable_EngineTypeID,//发动机类型转换表
out mes_MustTest, out onLineState, out partMoveDirection, out pressIsOK, out pressIsNoOK);
// 1:通过监控系统保存采集的质量数据;0:不通过监控系统保存采集的质量数据
if (Convert.ToInt32(hashtable_tagTable_OpName_SaveData[opName]) != 0)
{
DateTime lastupdatetime = DateTime.Now;
BaseDataSystemMES.BaseData_tagTable_QualityData_B5A_IndexInsert(engineID, tagID, engineType, engineTypeID, opName, qualityMask, partPallet, out id_tagCF);
BaseDataSystemMES.BaseData_tagTable_QualityData_B5A_Insert(id_tagCF, engineTypeID, engineID, opName, dt_WWW);
}
Write_TagTypeID(20, opName, true);
#region
//string orderForm = "";
//string operatorCode = "";
//int shiftCode = 1;
//DateTime arrivedTime;
//DateTime leavedTime;
//int TimeDiff;
//int targetTime = 0;
//string lineType = "";
//string isPass;
//int machineWorkOn = 0;
//int arrivedOrLeaved = 2;
//int cartColorOpName = 0;
//int cartColorConfirm = 0;
//// int partMoveDirection;
//int partGoOver = 0;
//if (qualityMask == 1)
//{
// isPass = "PASS";
//}
//else
//{
// isPass = "FAIL";
//}
////工位上下线类型
////（0普通工位）（1正常上线）（2正常下线）（3返修上线）（4返修下线）
//int OpNameUpDownType;
//OpNameUpDownType = Convert.ToInt32(hashtableOpName_OpType[opName]);
//arrivedTime = (DateTime)m_WorkStart_OpName_Time[opName];
//leavedTime = DateTime.Now;
//TimeDiff = Convert.ToInt32(leavedTime.Subtract(arrivedTime).TotalSeconds);
//lineType = hashtableOpName_LineType[opName].ToString();
//string isHaveComputer = hashtableOpName_IsHaveComputer[opName].ToString();
////isHaveComputer = MIS_BASE.hashtable_tagTable_OpName_SaveData[opName].ToString();
////有计算机的工位，通过工位计算机保存[测量数据发动机在线状态]。
//if (Convert.ToInt32(isHaveComputer) == 0)
//{
// //1->0 工件离开 工件刚刚离开
// if (Convert.ToInt32(m_WorkStart_OpName[opName]) == 1)
// {
// //[测量数据发动机在线状态]
// QualityDataSystem.WorkStartInsert
// (opName, orderForm, engineTypeID, engineType, engineID, partPallet.ToString(), operatorCode, shiftCode,
// arrivedTime, leavedTime, TimeDiff, targetTime, lineType, isPass, machineWorkOn,
// arrivedOrLeaved, cartColorOpName, cartColorConfirm, partMoveDirection, partGoOver, mes_MustTest, onLineState, OpNameUpDownType);
// }
//}
#endregion
}
catch (Exception err)
{
Write_TagTypeID(20, opName, true);
////ApplicationLog.WriteLog(err, err.Message);
}
}
public static void SaveQualityData_Mes(string opName, int tagID)
{
try
{
int id_tagCF;
int qualityMask = 0;
int engineTypeID = 0;
string engineID = "";
string engineType = "";
string engineTraceCode = "";
string engineCap = "";
string partPallet = "";
DataTable dt_WWW;
dt_WWW = BaseDataSystemMES.BuildDataTables_WWW();
Hashtable valueList;
valueList = ReadPLC_Sync_DataList_MesRead(opName);
valueList = GetQualityData_GoodBad_Values(valueList);
int mes_MustTest = 0;
int onLineState = 0;
int partMoveDirection = 0;
int pressIsOK = 0;
int pressIsNoOK = 0;
BaseDataSystemMES.GetQualityDataTable_B5A(valueList, opName, BasicDataTagValue,
BasicDataTagValueUpDown,
out dt_WWW,//数据列表
out qualityMask,//工位合格标志
out engineTypeID,//发动机类型代码
out engineID,//发动机编号
out engineType, //发动机型号
out partPallet,//托盘编号
out engineTraceCode, //发动机条码
out engineCap,//缸盖号,
hashtable_EngineTypeID,//发动机类型转换表
out mes_MustTest, out onLineState, out partMoveDirection, out pressIsOK, out pressIsNoOK);
// 1:通过监控系统保存采集的质量数据;0:不通过监控系统保存采集的质量数据
if (Convert.ToInt32(hashtable_tagTable_OpName_SaveData[opName]) != 0)
{
DateTime lastupdatetime = DateTime.Now;
BaseDataSystemMES.BaseData_tagTable_QualityData_B5A_IndexInsert(engineID, tagID, engineType, engineTypeID, opName, qualityMask, partPallet, out id_tagCF);
//BaseDataSystemMES.BaseData_tagTable_QualityData_B5A_Insert(id_tagCF, engineTypeID, engineID, opName, dt_WWW);
}
}
catch (Exception err)
{
Write_TagTypeID(20, opName, true);
////ApplicationLog.WriteLog(err, err.Message);
}
}
/// <summary>
/// 确定合格标志
/// </summary>
/// <param name="valuList"></param>
/// <returns></returns>
static public Hashtable GetQualityData_GoodBad_Values(Hashtable valuList)
{
try
{
Hashtable valuList_Temp;
valuList_Temp = (Hashtable)valuList.Clone();
int[] value_GoodBad_New = new int[128];
int tagID;
QualityDataType value;
//1：获得合格标志
foreach (DictionaryEntry de in valuList) //ht为一个Hashtable实例
{
tagID = Convert.ToInt32(de.Key);
value = (QualityDataType)de.Value;
//拧紧数据合格标志
if (value.tagProperty == 1)
{
if (value.tagTypeID == 8203)
{
value_GoodBad_New = (int[])value.tagValue;
break;
}
else
{
value_GoodBad_New[value.tagOrderBy - 1] = Convert.ToInt32(value.tagValue);
}
}
//拧紧数据合格标志
if (value.tagProperty == 8)
{
if (value.tagTypeID == 8203)
{
value_GoodBad_New = (int[])value.tagValue;
break;
}
else
{
value_GoodBad_New[value.tagOrderBy - 1] = Convert.ToInt32(value.tagValue);
}
}
//压装数据合格标志
if (value.tagProperty == 7)
{
value_GoodBad_New[value.tagOrderBy - 1] = Convert.ToInt32(value.tagValue);
}
}
//将合格标志赋予每个变量
foreach (DictionaryEntry de in valuList) //ht为一个Hashtable实例
{
tagID = Convert.ToInt32(de.Key);
value = (QualityDataType)de.Value;
//201706061720新加
if (value .tagTypeID ==11)
{
if (value.tagValue.ToString ()=="False")
{
value.tagValue ="0";
}
else
{
value.tagValue = "1";
}
valuList_Temp[tagID] = value;
//value.tagValue = Convert.ToInt32(value.tagValue);
}
//测量变量
if (value.tagProperty == 2 || value.tagProperty == 6)
{
try
{
if (value_GoodBad_New != null)
{
value.isGoodBad = Convert.ToInt32(value_GoodBad_New[value.tagOrderBy - 1]);
valuList_Temp[tagID] = value;
}
else
{
value.isGoodBad = 0;
valuList_Temp[tagID] = value;
}
}
catch (Exception err)
{
////ApplicationLog.WriteLog(err, err.Message);
}
}
}
return valuList_Temp;
}
catch//转换出了故障时
{
return valuList;
}
}
/// <summary>
/// 制定工位PLC是否传递过机型 （默认不传递机型不保存过站信息）
/// </summary>
static Hashtable EngTypeGetOver = new Hashtable();
static Hashtable EngineData_Hash = new Hashtable(); //保存
public static void IsEngTypeGetOver_Write(string OpName, bool value)
{
if (EngTypeGetOver.ContainsKey(OpName))
{
EngTypeGetOver[OpName] = value;
}
else
{
EngTypeGetOver.Add(OpName, value);
}
}
public static bool IsEngTypeGetOver_Read(string OpName)
{
if (EngTypeGetOver.ContainsKey(OpName))
{
return Convert.ToBoolean(EngTypeGetOver[OpName]);
}
else
{
return true;
}
}
public static void EngineData_Hash_Write(string OpName, object value)
{
if (EngineData_Hash.ContainsKey(OpName))
{
EngineData_Hash[OpName] = value;
}
else
{
EngineData_Hash.Add(OpName, value);
}
}
public static object EngineData_Hash_Read(string OpName)
{
if (EngineData_Hash.ContainsKey(OpName))
{
return EngineData_Hash[OpName];
}
else
{
return null;
}
}
private DataTable ChangeQualificationMark(DataTable dt)
{
var dtNew = dt.Copy();
for (int i = 0; i < dt.Rows.Count; i++)
{
var 变量排序 = dt.Rows[i]["变量排序"].ToString();
if (变量排序 == "0")
{
}
}
return dtNew;
}
}
struct EngineData
{
public EngineData(string engineID, int pallet)
{
EngineID = engineID;
Pallet = pallet;
}
public string EngineID;//工件编号
//public string EngineType;
//public int EngineTypeID;
public int Pallet;//托盘号
}
}

236
Common/09MesDataFunction/MesDataFunction/MisDataFunction/WorkStart.cs Normal file
View File

@@ -0,0 +1,236 @@
//using BasicData;
using bizFacade;
//using DataBaseAccess;
//using bizFacade;
using DataLinkMesWork;
using MesServerWork;
using System;
using System.Collections;
using System.Data;
using System.Data.SqlClient;
//using SystemFramework;
namespace MisDataFunction
{
partial class Function
{
/// <summary>
/// 工件到位与离开时，清空MES自身信号
/// </summary>
/// <param name="OpName"></param>
/// <param name="tagValue"></param>
private static void WorkStart(string opName, string tagValue)
{
try
{
//工位没有工件，或工件刚刚离开 工件离开工位后，清空该工位的发动机号
if (tagValue == "0")
{
Write_TagTypeID(5, opName, false);//MES传递机型
Write_TagTypeID(66, opName, false);//允许工作
Write_TagTypeID(51, opName, false);//合格放行
Write_TagTypeID(8, opName, false);//不合格放行
Write_TagTypeID(7, opName, false);//工作完成
Write_TagTypeID(20, opName, false);//保存完成
//string isHaveComputer = hashtableOpName_IsHaveComputer[opName].ToString();
//if (Convert.ToInt32(isHaveComputer) == 0)//自动工位 读合格标志
{
if (IsEngTypeGetOver_Read(opName))
{
//PLC未传递机型 不保存过站信息
SaveProductLeaveData_AutoWorkStation(opName, Convert.ToInt32(ReadPLC(21, opName)));
//SaveProductLeaveData_AutoWorkStation(opName, Convert.ToInt32(MesDataFunction.OpcOperation.ReadPLC(21, opName)));
}
}
//清空信号
//m_WorkStart_OpName[opName] = 0;//清空工件到位标志
//通知WEB更新产量
SendActuallyCount(opName,0);
}
else
{
//保存工件到达数据
//m_WorkStart_OpName_Time[opName] = DateTime.Now;
//m_WorkStart_OpName[opName] = 1;
}
}
catch (Exception err)
{
////ApplicationLog.WriteLog(err, err.Message);
}
}
/// <summary>
/// 保存过站信息 （数据库读机型信息）
/// </summary>
/// <param name="opName"></param>
/// <param name="QualityMark"></param>
static void SaveProductLeaveData(string opName, int QualityMark)
{
try
{
if (!IsEngTypeGetOver_Read(opName))
{
//PLC未传递机型 不保存过站信息
return;
}
IsEngTypeGetOver_Write(opName, false);//清空传递机型标志
DateTime arrivedTime;
DateTime leavedTime;
int TimeDiff;
int targetTime = 0;
string lineType = "";
string isPass;
if (QualityMark == 1)
{
isPass = "PASS";
}
else
{
isPass = "FAIL";
}
//工位上下线类型
//（0普通工位）（1正常上线）（2正常下线）（3返修上线）（4返修下线）
int OpNameUpDownType;
OpNameUpDownType = Convert.ToInt32(hashtableOpName_OpType[opName]);
arrivedTime = (DateTime)m_WorkStart_OpName_Time[opName];
leavedTime = DateTime.Now;
TimeDiff = Convert.ToInt32(leavedTime.Subtract(arrivedTime).TotalSeconds);
lineType = hashtableOpName_LineType[opName].ToString();
//1->0 工件离开 工件刚刚离开
//if (Convert.ToInt32(m_WorkStart_OpName[opName]) == 1)
//{
// WorkStartInsert(opName, arrivedTime, leavedTime, TimeDiff, targetTime, lineType, isPass, OpNameUpDownType);
//}
//通知WEB更新产量
SendActuallyCount(opName, 0);
}
catch (Exception err)
{
////ApplicationLog.WriteLog(err, err.Message);
}
}
/// <summary>
/// 保存过站信息 （数据库读机型信息）
/// </summary>
/// <param name="opName"></param>
/// <param name="QualityMark"></param>
static void SaveProductLeaveData_AutoWorkStation(string opName, int QualityMark)
{
try
{
if (!IsEngTypeGetOver_Read(opName))
{
//PLC未传递机型 不保存过站信息
return;
}
IsEngTypeGetOver_Write(opName, false);//清空传递机型标志
DateTime arrivedTime;
DateTime leavedTime;
int TimeDiff;
int targetTime = 0;
string lineType = "";
string isPass;
if (QualityMark == 1)
{
isPass = "PASS";
}
else
{
isPass = "FAIL";
}
//工位上下线类型
//（0普通工位）（1正常上线）（2正常下线）（3返修上线）（4返修下线）
int OpNameUpDownType;
//OpNameUpDownType = Convert.ToInt32(hashtableOpName_OpType[opName]);
// arrivedTime = (DateTime)m_WorkStart_OpName_Time[opName];
leavedTime = DateTime.Now;
//TimeDiff = Convert.ToInt32(leavedTime.Subtract(arrivedTime).TotalSeconds);
//lineType = hashtableOpName_LineType[opName].ToString();
//1->0 工件离开 工件刚刚离开
//if (Convert.ToInt32(m_WorkStart_OpName[opName]) == 1)
//{
// //查询工件编号、托盘号
//EngineData Enginedata = (EngineData)EngineData_Hash_Read(opName);
//WorkStartInsert_AutoWorkStation(opName, Enginedata.EngineID, Enginedata.Pallet, arrivedTime, leavedTime, TimeDiff, targetTime, lineType, isPass, OpNameUpDownType);
//}
}
catch (Exception err)
{
////ApplicationLog.WriteLog(err, err.Message);
}
}
/// <summary>
/// 测量数据发动机在线状态_增加数据
/// </summary>
/// <param name="opName"></param>
/// <param name="arrivedTime"></param>
/// <param name="leavedTime"></param>
/// <param name="TimeDiff"></param>
/// <param name="Target"></param>
/// <param name="isPass"></param>
static public void WorkStartInsert(string opName, DateTime arrivedTime, DateTime leavedTime, int TimeDiff, int Target, string lineType, string isPass, int OpNameUpDownType)
{
string procedureName;
procedureName = "测量数据发动机在线状态_增加数据";
SqlParameter[] thisParms = new SqlParameter[8];
thisParms[0] = new System.Data.SqlClient.SqlParameter("@工位号", opName);
thisParms[1] = new System.Data.SqlClient.SqlParameter("@到达时间", arrivedTime);
thisParms[2] = new System.Data.SqlClient.SqlParameter("@离开时间", leavedTime);
thisParms[3] = new System.Data.SqlClient.SqlParameter("@在线时间", TimeDiff);
thisParms[4] = new System.Data.SqlClient.SqlParameter("@目标时间", Target);
thisParms[5] = new System.Data.SqlClient.SqlParameter("@线体类型", lineType);
thisParms[6] = new System.Data.SqlClient.SqlParameter("@是否合格", isPass);
thisParms[7] = new System.Data.SqlClient.SqlParameter("@工位上下线类型", OpNameUpDownType);
DataAccess.ExecuteStoredProcedure(procedureName, ref thisParms);
}
/// <summary>
/// 发送在线产量、在线节拍
/// </summary>
/// <param name="OpName"></param>
/// <param name="tagValue"></param>
static void SendActuallyCount(string OpName, int tagValue)
{
//当工件离开时，更新在线产量、在线节拍
if (tagValue == 0)
{
try
{
int opNameCount = 0;//在线产量
int opNameCountTime = 0;//在线节拍
//基本数据_工作日历_班次产量查询_New
BaseDataSystemMES.OpNameCount_New(OpName, out opNameCount, out opNameCountTime);
string SendMessage;
SendMessage = "MES|ActuallyCount|" + OpName + "|" + opNameCount.ToString() + "&" + opNameCountTime.ToString();
MIS_BASE.asyncSendMessage(SendMessage);
}
catch (Exception err)
{
////ApplicationLog.WriteLog(err, "Function01:SendActuallyCount");
}
}
}
}
}