//写并置位
private void btnSetAndReset_Click(object sender, RoutedEventArgs e)
{
FmsAssetTagSetting tag = cmbTags.SelectedItem as FmsAssetTagSetting;
if (tag == null)
{
return;
}
string error = "";
string sTagValue = tbTagResult.Text;
DeviceMonitor.WriteTagToDevice(tag.PKNO, sTagValue, out error); //写入执行的值
if (!error.IsEmpty())
{
DeviceMonitor.WriteTagToDevice(tag.PKNO, sTagValue, out error); //写入执行的值
if (!error.IsEmpty())
{
tbTagResult.Text = error;
}
}
else
{
Thread.Sleep(200);
DeviceMonitor.WriteTagToDevice(tag.PKNO, "0", out error); //写入执行的值 置0
if (!error.IsEmpty())
{
DeviceMonitor.WriteTagToDevice(tag.PKNO, "0", out error); //写入执行的值 置0
if (!error.IsEmpty())
{
tbTagResult.Text = error;
}
}
}
}
private void BtnDel_Click(object sender, RoutedEventArgs e)
{
//删除
FmsAssetTagSetting assetTag = gridItem.SelectedItem as FmsAssetTagSetting;
if (assetTag == null)
{
return;
}
if (
MessageBox.Show($"确定要删除 标签名称【{assetTag.TAG_NAME}】的通讯标签配置信息吗？", "删除", MessageBoxButton.OKCancel,
MessageBoxImage.Question) != MessageBoxResult.OK)
{
return;
}
assetTag.USE_FLAG = (int)EmUseFlag.Deleted; //已删除
assetTag.UPDATED_BY = CBaseData.LoginName;
assetTag.LAST_UPDATE_DATE = DateTime.Now;
assetTag.UPDATED_INTROD += "删除 ";
_fmsClient.UseService(s => s.UpdateFmsAssetTagSetting(assetTag));
NotificationInvoke.NewNotification("删除提示", "设备通讯标签配置已删除！");
GetPage(); //重新刷新数据，根据需求是否进行刷新数据
}
private void BtnAdd_Click(object sender, RoutedEventArgs e)
{
//新增
#region
//TODO: 校验，空的类绑定到界面的DataContent
FmsAssetTagSetting assetTag = new FmsAssetTagSetting
{
PKNO = "",
ASSET_CODE = "",
STATE_MARK_TYPE = 0,
SAMPLING_MODE = 0,
RECORD_TYPE = 0, //默认不记录
USE_FLAG = 1
};
gbItem.DataContext = assetTag;
#endregion
dictBasic.Header = $"{HeaderName} 【新增】";
gbItem.IsCollapsed = false;
gbItem.Visibility = Visibility.Visible;
}
/// <summary>
/// 记录标签值
/// </summary>
/// <param name="tagSetting">标签配置信息</param>
/// <param name="tagValue">标签值</param>
private void TagValueRecord(FmsAssetTagSetting tagSetting, string tagValue)
{
lock (lockRecord)
{
try
{
EventLogger.Log($"======开始写入【{tagSetting.TAG_VALUE_NAME}】Record=====");
FmsSamplingRecord record = new FmsSamplingRecord
{
PKNO = CBaseData.NewGuid(),
ASSET_CODE = tagSetting.ASSET_CODE,
TAG_SETTING_PKNO = tagSetting.PKNO,
TAG_VALUE_NAME = tagSetting.TAG_VALUE_NAME,
TAG_VALUE = tagValue,
SAMPLING_TIME = DateTime.Now,
CREATION_DATE = DateTime.Now,
CREATED_BY = CBaseData.LoginName,
REMARK = "",
};
ws.UseService(s => s.AddFmsSamplingRecord(record));
EventLogger.Log($"======完成写入【{tagSetting.TAG_VALUE_NAME}】Record=====");
}
catch (Exception ex)
{
EventLogger.Log($"!!!!!!写入【{tagSetting.TAG_VALUE_NAME}】Record失败，原因:{ex.Message}!!!!!!");
}
}
}
//UI6下降沿
private void BtnPauseStart_Click(object sender, RoutedEventArgs e)
{
try
{
FmsAssetTagSetting tag = DeviceMonitor.GetTagSettings("TAG_CODE = 'UI6'").FirstOrDefault();
if (tag == null)
{
return;
}
Cursor = Cursors.Wait;
int ret = 0;
string error = "";
int iWrite = 0;
while (iWrite < ReWriteCount)
{
ret = DeviceMonitor.WriteTagToDevice(tag.PKNO, "1", out error);
if (ret == 0)
{
break;
}
iWrite++;
Thread.Sleep(100);
}
if (ret != 0)
{
Cursor = Cursors.Arrow;
return;
}
Thread.Sleep(500);
iWrite = 0;
while (iWrite < ReWriteCount)
{
ret = DeviceMonitor.WriteTagToDevice(tag.PKNO, "0", out error);
if (ret == 0)
{
break;
}
iWrite++;
Thread.Sleep(100);
}
Cursor = Cursors.Arrow;
if (ret == 0)
{
WPFMessageBox.ShowInfo("机器人的暂停后启动信息已经成功给出！", "启动机器人");
}
}
catch (Exception ex)
{
Cursor = Cursors.Arrow;
}
}
public FmsAssetTagSetting GetFmsAssetTagSettingById(string Id)
{
using (IFmsAssetTagSettingBLL FmsAssetTagSettingBLL = BLLContainer.Resolve <IFmsAssetTagSettingBLL>())
{
FmsAssetTagSetting model = FmsAssetTagSettingBLL.GetFirstOrDefault(Id);
return(model);
}
}
/// <summary>
/// 获取主轴刀号信息
/// </summary>
private void GetMainToolsInfo()
{
TmsDeviceToolsPos toolsPos = gridChangeTools.SelectedItem as TmsDeviceToolsPos;
if (toolsPos == null)
{
return;
}
//获取主轴刀号
FmsAssetTagSetting tagSetting =
wsFMS.UseService(
s =>
s.GetFmsAssetTagSettings(
$"USE_FLAG = 1 AND ASSET_CODE = '{toolsPos.DEVICE_PKNO}' AND TAG_NAME = '主轴刀号'"))
.FirstOrDefault();
if (tagSetting == null)
{
tbMainToolsNO.Text = "【主轴刀号】的Tag地址未设置！";
return;
}
FmsAssetCommParam device =
wsFMS.UseService(s => s.GetFmsAssetCommParams($"USE_FLAG = 1 AND ASSET_CODE = '{toolsPos.DEVICE_PKNO}'"))
.FirstOrDefault();
if (device == null)
{
tbMainToolsNO.Text = "设备未设置通讯信息！";
return;
}
string commAddress = device.COMM_ADDRESS;
DeviceCommInterface interfaceType = EnumHelper.ParserEnumByValue(device.INTERFACE_TYPE, DeviceCommInterface.CNC_Fanuc);
int period = Convert.ToInt32(device.SAMPLING_PERIOD); //采样周期
DeviceManager deviceCommunication = new DeviceManager(device.PKNO, interfaceType, commAddress, period * 1000);
List <DeviceTagParam> deviceTags = new List <DeviceTagParam>();
DeviceTagParam deviceTag = new DeviceTagParam(tagSetting.PKNO, tagSetting.TAG_CODE,
tagSetting.TAG_NAME, tagSetting.TAG_ADDRESS,
EnumHelper.ParserEnumByValue(tagSetting.VALUE_TYPE, TagDataType.Default),
EnumHelper.ParserEnumByValue(tagSetting.SAMPLING_MODE, DataSimplingMode.AutoReadDevice),
deviceCommunication); //通讯参数
deviceTags.Add(deviceTag); //添加
deviceCommunication.InitialDevice(deviceTags, null);
string error = "";
string sResult = deviceCommunication.SyncReadData(tagSetting.TAG_ADDRESS, out error);
if (error != "")
{
mainToolsNO = sResult;
}
tbMainToolsNO.Text = (error == "") ? "主轴刀号：T" + sResult : "读取主轴刀号错误，代码 " + error;
}
public bool AddFmsAssetTagSetting(FmsAssetTagSetting mFmsAssetTagSetting)
{
if (mFmsAssetTagSetting == null)
{
return(false);
}
using (IFmsAssetTagSettingBLL FmsAssetTagSettingBLL = BLLContainer.Resolve <IFmsAssetTagSettingBLL>())
{
return(FmsAssetTagSettingBLL.Add(mFmsAssetTagSetting));
}
}
public bool DelFmsAssetTagSetting(string Id)
{
using (IFmsAssetTagSettingBLL FmsAssetTagSettingBLL = BLLContainer.Resolve <IFmsAssetTagSettingBLL>())
{
try
{
FmsAssetTagSetting item = FmsAssetTagSettingBLL.GetFirstOrDefault(Id);
return(FmsAssetTagSettingBLL.Delete(item));
}
catch { return(false); }
}
}
private bool CopyTag()
{
jobTaskModel.Tags = DeviceMonitor.GetTagSettings("");
jobTaskModel.CopyTags = new List <FmsAssetTagSetting>();
foreach (var tag in jobTaskModel.Tags)
{
FmsAssetTagSetting copyTag = new FmsAssetTagSetting();
copyTag.CopyDataItem(tag);
jobTaskModel.CopyTags.Add(copyTag);
}
return(true);
}
private void SaveData(string pkno, string sReadResult)
{
try
{
FmsAssetTagSetting deviceTagSetting = _tagSettings.FirstOrDefault(c => c.PKNO == pkno);
if (deviceTagSetting == null)
{
return;
}
SaveData(deviceTagSetting, sReadResult);
}
catch (Exception)
{
}
}
private void SaveData(FmsAssetTagSetting deviceTagSetting, string sReadResult)
{
if (deviceTagSetting == null)
{
return;
}
lock (lockSave)
{
try
{
#region 条件保存记录到数据库
if (deviceTagSetting.RECORD_TYPE == 10) //持续结果的记录
{
new Thread(c => { TagValueResultRecord(deviceTagSetting, sReadResult); }).Start(); //持续结果记录
}
else if ((deviceTagSetting.RECORD_TYPE == 2) ||
((deviceTagSetting.RECORD_TYPE == 1) && (deviceTagSetting.CUR_VALUE != sReadResult))
) //一个周期记录一次或者有改变则记录
{
new Thread(c => { TagValueRecord(deviceTagSetting, sReadResult); }).Start(); //一个周期记录一次或者有改变则记录
}
#endregion
#region 将当前值反馈到改变中，便于更新数据库
if (deviceTagSetting.CUR_VALUE != sReadResult) //新的值 != 原值
{
if (CurValueChanged.ContainsKey(deviceTagSetting.PKNO))
{
CurValueChanged[deviceTagSetting.PKNO] = true; //当前值已经更新了
}
else
{
CurValueChanged.Add(deviceTagSetting.PKNO, true);
}
deviceTagSetting.CUR_VALUE = sReadResult; //更新当前值
}
#endregion
}
catch (Exception)
{
}
}
}
private void btnTestCopy_Click(object sender, RoutedEventArgs e)
{
copyTags.Clear();
#region 制当前Tag值，保证数据一致性，作为判断条件用
List <FmsAssetTagSetting> tags = DeviceMonitor.GetTagSettings("");
foreach (var tag in tags)
{
FmsAssetTagSetting copyTag = new FmsAssetTagSetting();
copyTag.CopyDataItem(tag);
copyTags.Add(copyTag);
}
#endregion
}
public bool ProductProgress()
{
productProcess = jobTaskMode.ProductProcesses.FirstOrDefault(c => c.PKNO == curProcess.CUR_PRODUCT_CODE_PKNO); //产品生产情况;
#region 当前工序的开始条件
startTag = jobTaskMode.CopyTags.FirstOrDefault(c => c.PKNO == curAction.START_CONDITION_TAG_PKNO);
startCondition = "";
if (startTag != null)
{
startCondition = startTag.PKNO + ".VALUE = " + curAction.START_CONDITION_VALUE;
}
#endregion
return(true);
}
public bool DelFmsAssetTagSettings(string[] Ids)
{
using (IFmsAssetTagSettingBLL FmsAssetTagSettingBLL = BLLContainer.Resolve <IFmsAssetTagSettingBLL>())
{
try
{
List <FmsAssetTagSetting> entitys = new List <FmsAssetTagSetting>();
foreach (string id in Ids)
{
FmsAssetTagSetting item = FmsAssetTagSettingBLL.GetFirstOrDefault(id);
entitys.Add(item);
}
return(FmsAssetTagSettingBLL.Delete(entitys));
}
catch { return(false); }
}
}
private void bToolsChange_Click(object sender, System.Windows.RoutedEventArgs e)
{
//换刀 向CNC发送换刀动作
TmsDeviceToolsPos toolsPos = gridChangeTools.SelectedItem as TmsDeviceToolsPos;
if (toolsPos == null)
{
return;
}
//获取主轴刀号
FmsAssetTagSetting tagSetting =
wsFMS.UseService(
s =>
s.GetFmsAssetTagSettings(
$"USE_FLAG = 1 AND ASSET_CODE = '{toolsPos.DEVICE_PKNO}' AND TAG_NAME = '机床换刀'"))
.FirstOrDefault();
if (tagSetting == null)
{
tbMainToolsNO.Text = "【机床换刀】的Tag地址未设置！";
return;
}
FmsAssetCommParam device =
wsFMS.UseService(s => s.GetFmsAssetCommParams($"USE_FLAG = 1 AND ASSET_CODE = '{toolsPos.DEVICE_PKNO}'"))
.FirstOrDefault();
if (device == null)
{
tbMainToolsNO.Text = "设备未设置通讯信息！";
return;
}
string commAddress = device.COMM_ADDRESS;
int interfaceType = device.INTERFACE_TYPE;
int period = Convert.ToInt32(device.SAMPLING_PERIOD); //采样周期
OperateResult ret = DeviceHelper.WriteDataByAddress(device.ASSET_CODE, interfaceType, commAddress,
tagSetting.PKNO, tagSetting.TAG_ADDRESS, toolsPos.TOOLS_POS_NO);
tbMainToolsNO.Text = (ret.IsSuccess) ? "机床换刀准备 " + toolsPos.TOOLS_POS_NO : "发送换刀指令错误，代码 " + ret.Message;
if (ret.IsSuccess)
{
mainToolsNO = ""; //开始换刀
}
}
public string GetTagPkno(string tagpkno)
{
if (tagpkno == "")
{
return(tagpkno);
}
FmsAssetTagSetting tageTagSetting = ws.UseService(s => s.GetFmsAssetTagSettingById(tagpkno));
if (tageTagSetting.ASSET_CODE == "SH00001")
{
FmsAssetTagSetting tageTagSettinglike = ws.UseService(s => s.GetFmsAssetTagSettings("TAG_ADDRESS = " + tageTagSetting.TAG_ADDRESS + " AND ASSET_CODE = 'SH00003'")).FirstOrDefault();
if (tageTagSettinglike != null)
{
return(tageTagSettinglike.PKNO);
}
}
return(tagpkno);
}
/// <summary>
/// 向设备写入标签值
/// </summary>
/// <param name="tagPKNO"></param>
/// <param name="value"></param>
/// <param name="error">输出错误信息</param>
/// <returns>0:成功；1:标签PKNO为空；2：标签不存在;3:通讯设备不存在；10：写入设备失败</returns>
public static int WriteTagToDevice(string tagPKNO, string value, out string error)
{
int ret = 0;
error = "";
if (string.IsNullOrEmpty(tagPKNO))
{
error = "标签PKNO为空";
return(1);
}
FmsAssetTagSetting tagSetting = GetTagSettingById(tagPKNO);
if (tagSetting == null)
{
error = "标签不存在";
return(2);
}
FmsAssetCommParam deviceCommParam = _devices.FirstOrDefault(c => c.ASSET_CODE == tagSetting.ASSET_CODE);
if (deviceCommParam == null)
{
error = "通讯设备不存在";
return(3);
}
OperateResult result = DeviceHelper.WriteDataByAddress(deviceCommParam.ASSET_CODE,
deviceCommParam.INTERFACE_TYPE, deviceCommParam.COMM_ADDRESS,
tagSetting.PKNO, tagSetting.TAG_ADDRESS, value); //写入设备
if (!result.IsSuccess)
{
error = "向设备写入失败，错误：" + result.Message;
return(10);
}
//更新当前值
SetTagSettingValue(tagSetting, value);
return(ret);
}
/// <summary>
/// 设置Tag点的值，结果OK
/// </summary>
/// <param name="tagSetting">Tag点</param>
/// <param name="newValue">新的值</param>
/// <returns>OK;错误代码</returns>
public static string SetTagSettingValue(FmsAssetTagSetting tagSetting, string newValue)
{
string error = "OK";
if (tagSetting == null)
{
return("标签参数为空");
}
try
{
if (bMonitor) //已经开启监控
{
if (tagSetting.CUR_VALUE != newValue) //新的值 != 原值
{
if (CurValueChanged.ContainsKey(tagSetting.PKNO))
{
CurValueChanged[tagSetting.PKNO] = true; //当前值已经更新了
}
else
{
CurValueChanged.Add(tagSetting.PKNO, true);
}
tagSetting.CUR_VALUE = newValue; //更新当前值
}
}
else //没有开启监控
{
tagSetting.CUR_VALUE = newValue;
WcfClient <IFMSService> wsThis = new WcfClient <IFMSService>();
wsThis.UseService(s => s.UpdateFmsAssetTagSetting(tagSetting));
}
}
catch (Exception e)
{
error = "手动更新Tag点的值失败，具体 " + e.Message;
Console.WriteLine(error);
}
return(error);
}
private void ReadThread(object obj)
{
FmsAssetTagSetting tag = obj as FmsAssetTagSetting;
if (tag == null)
{
return;
}
string error = "";
string value = DeviceMonitor.ReadTagFormDevice(tag.PKNO, out error);
if (!error.IsEmpty())
{
value = error;
}
Dispatcher.BeginInvoke((Action)(delegate()
{
tbTagResult.Text = value;
}));
}
//写
private void Button_Click_4(object sender, RoutedEventArgs e)
{
FmsAssetTagSetting tag = cmbTags.SelectedItem as FmsAssetTagSetting;
if (tag == null)
{
return;
}
string error = "";
string sTagValue = tbTagResult.Text;
DeviceMonitor.WriteTagToDevice(tag.PKNO, sTagValue, out error); //写入执行的值
if (!error.IsEmpty())
{
DeviceMonitor.WriteTagToDevice(tag.PKNO, sTagValue, out error); //写入执行的值
if (!error.IsEmpty())
{
tbTagResult.Text = error;
}
}
}
private void CmbTag_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
{
FmsAssetTagSetting tag = cmbTag.SelectedItem as FmsAssetTagSetting;
if (tag == null)
{
tbTagType.Text = "请选择Tag";
return;
}
string stateName = "未知";
int state = tag.STATE_MARK_TYPE ?? 0;
if (state == 0)
{
stateName = "普通";
}
else if (state == 1)
{
stateName = "状态-脱机";
}
else if (state == 3)
{
stateName = "状态-工作";
}
else if (state == 4)
{
stateName = "状态-故障";
}
else if (state == 10)
{
stateName = "状态";
}
else if (state == 11)
{
stateName = "位移";
}
tbTagType.Text = stateName;
}
public bool Init()
{
if ((RunState != 1) && (!CBaseData.AppClosing)) //正在运行才执行
{
return(false);
}
#region 整线报警
FmsAssetTagSetting alertTag = DeviceMonitor.GetTagSettings("TAG_CODE = '整线报警'").FirstOrDefault();
string alertValue = alertTag?.CUR_VALUE;
if (alertValue == "1") //有整线报警，系统退出
{
//break;
}
#endregion
FMSControlService.iConditionStartAddPause = 10; //条件启动启动后附加的延时 正常10ms，按条件启动后500ms
FMSControlService.bStart = false; //已经启动了，只要启动了就重新获取订单信息
return(true);
}
/// <summary>
/// 获取动态文本的值
/// </summary>
/// <param name="text">文本</param>
/// <returns>转换后的值</returns>
private string GetDynamicValue(string text)
{
if (string.IsNullOrEmpty(text))
{
return("");
}
string result = text;
if (text.Length > 4) //"{[TagCode]}形式"
{
if ((text.Substring(0, 2) == "{[") && (text.Substring(text.Length - 2) == "]}")) //按照TagCode获取Tag点的当前
{
string tagCode = text.Substring(2, text.Length - 4); //
FmsAssetTagSetting tag = DeviceMonitor.GetTagSettings($"TAG_CODE = '{tagCode}'").FirstOrDefault();
if (tag != null)
{
result = tag.CUR_VALUE; //
}
}
}
return(result);
}
private const int ReWriteCount = 3; //数据重写次数
//下发刀补
private void btnWriteToolsSet_Click(object sender, RoutedEventArgs e)
{
AmAssetMasterN asset = cmbDeviceInfo.SelectedItem as AmAssetMasterN;
if (asset == null)
{
return;
}
TmsDeviceToolsPos mTmsDeviceToolsPos = gridItem.SelectedItem as TmsDeviceToolsPos;
if (mTmsDeviceToolsPos == null)
{
return;
}
TmsToolsMaster tools = ws.UseService(s => s.GetTmsToolsMasterById(mTmsDeviceToolsPos.TOOLS_PKNO));
if (tools == null)
{
return;
}
if (WPFMessageBox.ShowConfirm($"确定要将机床【{asset.ASSET_NAME}】上刀号【{mTmsDeviceToolsPos.TOOLS_POS_NO}】的补偿值覆盖吗？",
"下发刀补") != WPFMessageBoxResult.OK)
{
return;
}
Cursor = Cursors.Wait;
string tagName = "写入刀补";
FmsAssetTagSetting tag = DeviceMonitor.GetTagSettings($"ASSET_CODE = '{asset.ASSET_CODE}' AND TAG_NAME = '{tagName}'").FirstOrDefault();
if (tag == null)
{
Cursor = Cursors.Arrow;
return;
}
//0：长度(形状)；1：长度(磨损)；2：半径(形状)；3：半径(磨损)
List <string> values = new List <string>();
values.Add(mTmsDeviceToolsPos.TOOLS_POS_NO); //机床刀号
values.Add(tools.COMPENSATION_SHAPE_LENGTH.ToString()); //长度(形状)
//values.Add(tools.COMPENSATION_ABRASION_LENGTH.ToString()); //长度(磨损)
values.Add(tools.COMPENSATION_SHAPE_DIAMETER.ToString()); //半径(形状)
//values.Add(tools.COMPENSATION_ABRASION_DIAMETER.ToString()); //半径(磨损)
string offSetValue = string.Join("|", values.ToArray());
#region 发刀补
int iWrite = 0;
int ret = 0;
string error = "";
while (iWrite < ReWriteCount)
{
ret = DeviceMonitor.WriteTagToDevice(tag.PKNO, offSetValue, out error);
if (ret == 0)
{
break;
}
iWrite++;
Thread.Sleep(100);
}
#endregion
Cursor = Cursors.Arrow;
if (ret == 0)
{
WPFMessageBox.ShowTips("刀补值下发成功!", "下发刀补");
}
}
/// <summary>
/// 状态类标签值保存结果
/// </summary>
/// <param name="tagSetting"></param>
/// <param name="tagValue"></param>
private void TagValueResultRecord(FmsAssetTagSetting tagSetting, string tagValue)
{
const int addMinutes = -10; //分钟
const int spanSaveSec = -5; //每个5秒更新结束时间
lock (lockResultRecord)
{
try
{
EventLogger.Log($"======开始写入【{tagSetting.TAG_VALUE_NAME}】Result=====");
DateTime dtNow = DateTime.Now;
List <FmsStateResultRecord> records =
ws.UseService(
s =>
s.GetFmsStateResultRecords(
$"ASSET_CODE = '{tagSetting.ASSET_CODE}' AND TAG_SETTING_PKNO = '{tagSetting.PKNO}' " +
$"AND END_TIME >= '{dtNow.AddMinutes(addMinutes * 2)}'")) //2倍时间以上时不再继续续写
.OrderByDescending(c => c.END_TIME)
.ThenByDescending(c => c.BEGINT_TIME)
.ThenByDescending(c => c.CREATION_DATE)
.ToList();
FmsStateResultRecord oldRecord = records.FirstOrDefault();
bool bFirstRecord = !ResultRecordFirsts.ContainsKey(tagSetting.PKNO) ||
ResultRecordFirsts[tagSetting.PKNO];
bool isAddNewResult = (bFirstRecord) || (oldRecord == null) || (oldRecord.TAG_VALUE != tagValue) ||
(oldRecord.END_TIME <= dtNow.AddMinutes(addMinutes)) || //10分钟之前的数据则重新增加;
(oldRecord.END_TIME.Value.Date != dtNow.Date); //跨天数据则新增加
if ((!bFirstRecord) && (oldRecord != null)) //不是第一次运行则修改之前的时间，一个周期更新一次结束时间+++++
{
if ((isAddNewResult) || (oldRecord.END_TIME <= dtNow.AddSeconds(spanSaveSec))) //新增记录时，修改原值
{
oldRecord.END_TIME = dtNow; //更新状态时间
ws.UseService(s => s.UpdateFmsStateResultRecord(oldRecord));
}
}
if (isAddNewResult) //新增值
{
#region 新增值
FmsStateResultRecord record = new FmsStateResultRecord
{
PKNO = CBaseData.NewGuid(),
ASSET_CODE = tagSetting.ASSET_CODE,
TAG_SETTING_PKNO = tagSetting.PKNO,
TAG_VALUE_NAME = tagSetting.TAG_VALUE_NAME,
TAG_VALUE = tagValue,
BEGINT_TIME = dtNow,
END_TIME = DateTime.Now,
CREATION_DATE = DateTime.Now,
CREATED_BY = CBaseData.LoginName,
REMARK = "",
};
ws.UseService(s => s.AddFmsStateResultRecord(record));
#endregion
}
if (!ResultRecordFirsts.ContainsKey(tagSetting.PKNO))
{
ResultRecordFirsts.Add(tagSetting.PKNO, false); //不是第一次
}
else
{
ResultRecordFirsts[tagSetting.PKNO] = false;
}
EventLogger.Log($"======完成写入【{tagSetting.TAG_VALUE_NAME}】Result=====");
}
catch (Exception ex)
{
EventLogger.Log($"!!!!!!写入【{tagSetting.TAG_VALUE_NAME}】Result失败，原因:{ex.Message}!!!!!!");
}
}
}
public bool FinishProgress()
{
if (curProcess.PROCESS_STATE == 2) //正在执行，完成该动作
{
if (!string.IsNullOrEmpty(startCondition) && !LimitConditions.Contains(startCondition)) //未完成的任务需要增加开始条件
{
LimitConditions.Add(startCondition);
}
#region 完成执行工序 共 3 步
/************ ！！！工序完成的条件！！！ ************/
string sCurFinishValue = ""; //当前完成的结果
#region 1. 检验当前工序是否完成，未完成，则下一个任务
FmsAssetTagSetting finishTag = jobTaskMode.CopyTags.FirstOrDefault(c => c.PKNO == curAction.FINISH_CONDITION_TAG_PKNO);
if (finishTag != null)
{
string condition = finishTag.PKNO + ".VALUE = " + curAction.FINISH_CONDITION_VALUE;
//如果前面的Job存在需要判断该状态，则不执行完成当前
if ((startCondition != condition) && LimitConditions.Contains(condition))
{
string sErrorInfo =
$"正在执行[{ctrolName}],完成条件[{finishTag?.TAG_NAME}]不足.";
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(s => s.UpdateMesJobOrder(mesJobOrder));
}
if (FMSControlService.bStart)
{
return(true);
}
}
if (finishTag.SAMPLING_MODE == 11) //动作开始后自动开启 => 尚未开启，需要开启
{
var tag0 = DeviceMonitor.GetTagSettingById(curAction.FINISH_CONDITION_TAG_PKNO);
tag0.SAMPLING_MODE = 10; //尚未开启，需要开启
DeviceMonitor.SetTagSettingValue(tag0, ""); //清空完成条件
if (FMSControlService.bStart)
{
return(true);
}
}
sCurFinishValue = finishTag.CUR_VALUE; //当前设备的值
string checkValue = sCurFinishValue.Split('|')[0]; //多结果情况，适用于检测
string finishValue = curAction.FINISH_CONDITION_VALUE;
string[] finishValues = finishValue.Split('|'); //多个完成条件
if (!finishValues.Contains(checkValue)) //当前值不是工序结束值，不完成
{
string sErrorInfo =
$"正在执行[{ctrolName}],获取到完成结果为[{checkValue}]，判断完成条件为[{finishValue}]，生产过程[{ctrolName}]尚未完成.";
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(s => s.UpdateMesJobOrder(mesJobOrder));
}
if (!LimitConditions.Contains(condition))
{
LimitConditions.Add(condition); //完成条件不满足
}
if (FMSControlService.bStart)
{
return(true);
}
}
//移除完成限制条件
LimitConditions.Remove(condition); //完成条件满足 则移除不满足的条件
if (string.IsNullOrEmpty(startCondition))
{
LimitConditions.Remove(startCondition); //移除开始的限制条件
}
}
else //没有动作完成的检测值，手动完成。
{
string sErrorInfo = $"生产过程[{ctrolName}]没有设置过程完成的检测值，请手动完成该过程."; //生产执行信息
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(s => s.UpdateMesJobOrder(mesJobOrder));
}
if (string.IsNullOrEmpty(startCondition))
{
LimitConditions.Remove(startCondition); //移除开始的限制条件
}
if (FMSControlService.bStart)
{
return(true);
}
}
#endregion
/************ ！！！工序已经完成！！！ ************/
Console.WriteLine($"收到设备完成指令，完成反馈结果为[{sCurFinishValue}]，完成生产过程[{ctrolName}]");
#region 2. 根据工序类型处理 完成当前工序
if (curProcess.PROCESS_ACTION_TYPE == 3) //检测完成
{
//合格数量
string[] checkResult = sCurFinishValue.Split('|');
int qualifiedNumber = 1; //合格品数量
if (checkResult.Count() >= 2)
{
qualifiedNumber = SafeConverter.SafeToInt(checkResult[1], 1);
}
curProcess.COMPLETE_QTY = qualifiedNumber; //生产数量 - 含不合格的丢弃
curProcess.QUALIFIED_QTY = qualifiedNumber; //合格品数量
mesJobOrder.ONLINE_QTY = mesJobOrder.ONLINE_QTY - firstProcess.PROCESS_QTY + curProcess.QUALIFIED_QTY; //在线数量，更新再制品数量
if (mesJobOrder.ONLINE_QTY < 0)
{
mesJobOrder.ONLINE_QTY = 0;
}
}
if (productProcess != null)
{
if (bLastProcess)
{
productProcess.PRODUCT_STATE = 100; //最后一道工序 正常完成
}
string result = DeviceProcessControl.FinishCurBusiness(curProcess); //完成业务
if (result != "OK")
{
string sErrorInfo = $"业务完成失败，写入数据库错误！";
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(s => s.UpdateMesJobOrder(mesJobOrder));
}
}
}
#region 已删除 - 之前的方式
if (curProcess.PROCESS_ACTION_TYPE == 1) //加工完成
{
//if (productProcess != null)
//{
// productProcess.CUR_ITEM_PKNO = curProcess.FINISH_ITEM_PKNO; //生产完成
//}
}
else if (curProcess.PROCESS_ACTION_TYPE == 2) //搬运完成
{
//if (productProcess != null)
//{
// productProcess.PRODUCT_POSITION = curProcess.FINISH_POSITION; //目标位置
//}
}
else if (curProcess.PROCESS_ACTION_TYPE == 3) //检测完成
{
//合格数量
string[] result = sCurFinishValue.Split('|');
int qualifiedNumber = 1; //合格品数量
if (result.Count() >= 2)
{
qualifiedNumber = SafeConverter.SafeToInt(result[1], 1);
}
curProcess.COMPLETE_QTY = qualifiedNumber; //生产数量 - 含不合格的丢弃
curProcess.QUALIFIED_QTY = qualifiedNumber; //合格品数量
mesJobOrder.ONLINE_QTY = mesJobOrder.ONLINE_QTY - firstProcess.PROCESS_QTY + curProcess.QUALIFIED_QTY; //在线数量，更新再制品数量
if (mesJobOrder.ONLINE_QTY < 0)
{
mesJobOrder.ONLINE_QTY = 0;
}
}
else if (curProcess.PROCESS_ACTION_TYPE == 11) //出库完成
{
//if (productProcess != null) productProcess.PRODUCT_POSITION = curProcess.FINISH_POSITION; //目标位置
//#region 解锁货位地址 - 货位清空
//if (!string.IsNullOrEmpty(curProcess.BEGIN_POSITION))
//{
// WmsAllocationInfo rawAllo = wsWMS.UseService(s =>
// s.GetWmsAllocationInfoById(curProcess.BEGIN_POSITION));
// if (rawAllo != null)
// {
// rawAllo.CUR_PALLET_NO = "";
// rawAllo.ALLOCATION_STATE = 0; //空
// wsWMS.UseService(s => s.UpdateWmsAllocationInfo(rawAllo));
// WmsInventory inv = wsWMS.UseService(s => s.GetWmsInventorys($"ALLOCATION_PKNO = '{rawAllo.PKNO}'"))
// .FirstOrDefault();
// if (inv != null) wsWMS.UseService(s => s.DelWmsInventory(inv.PKNO));
// }
//}
//#endregion
}
else if (curProcess.PROCESS_ACTION_TYPE == 12) //入库完成
{
//if (productProcess != null) productProcess.PRODUCT_POSITION = curProcess.FINISH_POSITION; //目标位置
//#region 产品入库处理 - 解锁货位地址、增加产品库存
//if (!string.IsNullOrEmpty(curProcess.FINISH_POSITION))
//{
// WmsAllocationInfo prodAllo = wsWMS.UseService(s =>
// s.GetWmsAllocationInfoById(curProcess.FINISH_POSITION));
// if (prodAllo != null) //入库货位
// {
// prodAllo.ALLOCATION_STATE = 100; //满货位
// WmsInventory inv = new WmsInventory()
// {
// PKNO = CBaseData.NewGuid(),
// COMPANY_CODE = "",
// MATERIAL_PKNO = curProcess.FINISH_ITEM_PKNO,
// ALLOCATION_PKNO = prodAllo.PKNO,
// AREA_PKNO = prodAllo.AREA_PKNO,
// BATCH_NO = curProcess.SUB_JOB_ORDER_NO,
// INVENTORY_NUM = 1, //curProcess.QUALIFIED_QTY?? 1,
// REMARK = "",
// }; //库存
// wsWMS.UseService(s => s.UpdateWmsAllocationInfo(prodAllo)); //修改货位
// wsWMS.UseService(s => s.AddWmsInventory(inv));
// }
//}
//#endregion
}
else if ((curProcess.PROCESS_ACTION_TYPE >= 40) &&
(curProcess.PROCESS_ACTION_TYPE < 50)) //换刀
{
//40：换刀；41：取刀；42：卸刀；43：装刀；44：放刀
//if (curProcess.PROCESS_ACTION_TYPE == 41) //取刀
//{
// TmsToolsMaster mToolsMaster = wsTMS.UseService(s =>
// s.GetTmsToolsMasterById(curProcess.BEGIN_ITEM_PKNO)); //装上刀具
// if (mToolsMaster != null)
// {
// mToolsMaster.TOOLS_POSITION = 10; //出库
// mToolsMaster.TOOLS_POSITION_PKNO = "";
// wsTMS.UseService(s => s.UpdateTmsToolsMaster(mToolsMaster));
// }
//}
//else if (curProcess.PROCESS_ACTION_TYPE == 42) //卸刀
//{
// TmsDeviceToolsPos mTmsDeviceToolsPos = wsTMS.UseService(s => s.GetTmsDeviceToolsPosById(curProcess.BEGIN_ITEM_PKNO)); //卸下刀具
// if (mTmsDeviceToolsPos != null)
// {
// mTmsDeviceToolsPos.TOOLS_PKNO = "";
// wsTMS.UseService(s => s.UpdateTmsDeviceToolsPos(mTmsDeviceToolsPos)); //更新
// }
// TmsToolsMaster mToolsMaster = wsTMS.UseService(s =>
// s.GetTmsToolsMasterById(curProcess.FINISH_ITEM_PKNO)); //卸下刀具
// if (mToolsMaster != null)
// {
// mToolsMaster.TOOLS_POSITION = 10; //已出库
// mToolsMaster.TOOLS_POSITION_PKNO = "";
// wsTMS.UseService(s => s.UpdateTmsToolsMaster(mToolsMaster)); //已出库
// }
//}
//else if (curProcess.PROCESS_ACTION_TYPE == 43) //装刀
//{
// TmsDeviceToolsPos mTmsDeviceToolsPos = wsTMS.UseService(s => s.GetTmsDeviceToolsPosById(curProcess.BEGIN_ITEM_PKNO)); //装上刀具
// if (mTmsDeviceToolsPos != null)
// {
// mTmsDeviceToolsPos.TOOLS_PKNO = curProcess.FINISH_ITEM_PKNO; //装上刀具PKNO
// wsTMS.UseService(s => s.UpdateTmsDeviceToolsPos(mTmsDeviceToolsPos)); //更新
// }
// TmsToolsMaster mToolsMaster = wsTMS.UseService(s =>
// s.GetTmsToolsMasterById(curProcess.FINISH_ITEM_PKNO)); //装上刀具PKNO
// if (mToolsMaster != null)
// {
// mToolsMaster.TOOLS_POSITION = 2; //在设备
// mToolsMaster.TOOLS_POSITION_PKNO = curProcess.BEGIN_POSITION; //装刀机床PKNO
// wsTMS.UseService(s => s.UpdateTmsToolsMaster(mToolsMaster)); //已出库
// }
//}
//else if (curProcess.PROCESS_ACTION_TYPE == 44) //放刀
//{
// TmsToolsMaster mToolsMaster = wsTMS.UseService(s =>
// s.GetTmsToolsMasterById(curProcess.BEGIN_ITEM_PKNO)); //卸下刀具
// if (mToolsMaster != null)
// {
// mToolsMaster.TOOLS_POSITION = 1;
// mToolsMaster.TOOLS_POSITION_PKNO = curProcess.FINISH_ITEM_PKNO; //位置信息
// wsTMS.UseService(s => s.UpdateTmsToolsMaster(mToolsMaster)); //已出库
// }
//}
}
#endregion
#endregion
#region 3. 更新数据 共更新 4 个类
#region 3.1 加工控制
curProcess.PROCESS_END_TIME = DateTime.Now;
curProcess.PROCESS_STATE = 10;
curProcess.PROCESS_END_TYPE = 1;
PServiceEvent?.Invoke(s => s.UpdateMesProcessCtrol(curProcess));
#endregion
#region 3.2 Job处理
#region 最后一道工序的处理
mesJobOrder.PROCESS_INFO = "正常"; //生产执行信息
if (bLastProcess) //最后一道工序
{
mesJobOrder.COMPLETE_QTY = curProcess.COMPLETE_QTY;
mesJobOrder.ONLINE_QTY = 0; //任务完成
mesJobOrder.ACT_FINISH_TIME = DateTime.Now;
mesJobOrder.RUN_STATE = 100; //正常完成
mesJobOrder.PROCESS_INFO = $"正常完成，计划数量[{mesJobOrder.TASK_QTY}]，完成数量[{mesJobOrder.COMPLETE_QTY}]";
Console.WriteLine($"订单[{mesJobOrder.JOB_ORDER_NO}]生产完成，计划数量[{mesJobOrder.TASK_QTY}]，完成数量[{mesJobOrder.COMPLETE_QTY}]");
}
#endregion
PServiceEvent?.Invoke(s => s.UpdateMesJobOrder(mesJobOrder));
#endregion
#region 3.4 清空完成反馈状态，将完成条件置空
var tag = DeviceMonitor.GetTagSettingById(curAction.FINISH_CONDITION_TAG_PKNO);
if (tag != null) //将完成结果置为空
{
if (tag.SAMPLING_MODE == 10)
{
tag.SAMPLING_MODE = 11; //按照条件关闭
}
DeviceMonitor.SetTagSettingValue(tag, "");
}
#endregion
#endregion
#endregion
Thread.Sleep(50);
return(true);
}
return(true);
}
/// <summary>
/// 自动保存实时结果
/// </summary>
private void ThreadSaveCurValue()
{
int runSpan = 0; //循环变量
WcfClient <IFMSService> wsThis = new WcfClient <IFMSService>();
while (!CBaseData.AppClosing)
{
#region 暂停
if ((bPause) || (SaveCurValueSpan <= 0))
{
System.Threading.Thread.Sleep(200);
continue;
}
#endregion
runSpan++;
if (runSpan % (SaveCurValueSpan * 10) == 0) //到达周期
{
#region 自动保存当前值到Tag点
lock (lockUpdateCurValue)
{
try
{
foreach (FmsAssetTagSetting deviceTagSetting in _tagSettings)
{
if (CurValueChanged.ContainsKey(deviceTagSetting.PKNO))
{
if (!CurValueChanged[deviceTagSetting.PKNO])
{
continue; //没有更新则退出
}
}
else
{
CurValueChanged.Add(deviceTagSetting.PKNO, false);
}
FmsAssetTagSetting changeValue = wsThis.UseService(s =>
s.GetFmsAssetTagSettingById(deviceTagSetting.PKNO));
if (changeValue == null)
{
continue;
}
changeValue.CUR_VALUE = deviceTagSetting.CUR_VALUE;
wsThis.UseService(s => s.UpdateFmsAssetTagSetting(changeValue)); //只更新当前值到数据库
if ((CurValueChanged.ContainsKey(deviceTagSetting.PKNO)) &&
(CurValueChanged[deviceTagSetting.PKNO]))
{
CurValueChanged[deviceTagSetting.PKNO] = false; //更新完成
}
}
}
catch (Exception)
{
}
}
#endregion
runSpan = 0;
}
System.Threading.Thread.Sleep(100);
}
}
/// <summary>
/// 自动计算标签值
/// 采用动态代码执行方式，编译一次，采用参数传入的方式执行
/// </summary>
private void ThreadAutoCalculation()
{
Type dynamicCode = null; //获取编译后代码，调用该类用
List <FmsTagCalculation> TagCalculations = null; //计算规则
Dictionary <string, Dictionary <string, string> > FuncAndParamTagPKNO = new Dictionary <string, Dictionary <string, string> >(); //函数和对应参数的Tag的PKNO
while (!CBaseData.AppClosing)
{
#region 暂停
if (bPause)
{
System.Threading.Thread.Sleep(200);
continue;
}
#endregion
try
{
int index;
if (bRefreshAutoCal) //刷新计算规则
{
WcfClient <IFMSService> wsThis = new WcfClient <IFMSService>();
TagCalculations = wsThis.UseService(s => s.GetFmsTagCalculations("USE_FLAG = 1"));
bRefreshAutoCal = false;
if ((TagCalculations == null) || (!TagCalculations.Any()))
{
Thread.Sleep(500);
continue;
}
string className = "C" + Guid.NewGuid().ToString("N");
#region 形成执行的代码
string execCode = "using System; \r\n" +
"using System.Text; \r\n" +
"using System.Collections.Generic; \r\n" +
"using BFM.Common.Base; \r\n\r\n";
execCode += "public class " + className + "\r\n" +
"{ \r\n";
string basicFuc = "AutoCalculation";
index = 1;
FuncAndParamTagPKNO.Clear();
foreach (FmsTagCalculation calculation in TagCalculations)
{
FmsAssetTagSetting tagResult = GetTagSettingById(calculation.RESULT_TAG_PKNO); //结果
string exp = calculation.CALCULATION_EXPRESSION; //表达式
string funcname = basicFuc + index.ToString(); //函数名称
Dictionary <string, string> paramTas = new Dictionary <string, string>(); //参数对应的标签的PKNO, param
List <string> funcParam = new List <string>(); //带类型的参数
string code = "";
string resultType = "string";
//将标签替换成参数名
foreach (var line in exp.Split(new string[] { "\r\n" }, StringSplitOptions.None))
{
string ret = line;
#region 替换标签值，将标签替换成参数名
string[] expTags = line.Split('{');
for (int i = 0; i < expTags.Length; i++)
{
string str = expTags[i];
int length = str.IndexOf('}');
if (length < 0) //没有找到 }
{
continue;
}
string tagPKNO = str.Substring(0, length); //{ } 内为PKNO
string param = "{" + tagPKNO + "}";
if (paramTas.ContainsKey(tagPKNO)) //已经添加了该参数
{
param = paramTas[tagPKNO];
}
else
{
FmsAssetTagSetting tag = GetTagSettingById(tagPKNO);
if (tag == null)
{
continue;
}
param = "param" + paramTas.Count;
paramTas.Add(tagPKNO, param);
string paramType = "string"; //所有参数传入都是string型
//string paramType =
// ((calculation.CALCULATION_TYPE == 2) ||
// (tag.VALUE_TYPE > 0 && tag.VALUE_TYPE < 20))
// ? "double"
// : "string";
funcParam.Add(paramType + " " + param);
}
ret = ret.Replace("{" + tagPKNO + "}", param);
}
#endregion
if (string.IsNullOrEmpty(code))
{
code = " " + ret;
}
else
{
code += Environment.NewLine + " " + ret;
}
}
//确定返回结果类型，将code语句转换成C#的语句
if (calculation.CALCULATION_TYPE == 1) //逻辑运算
{
//（结果为1,0):({标签1}==1)&&({标签2}==1)&&({标签3}==0||{标签4}==0)&&({标签5}==1)
code = code.Replace("AND", "&&").Replace("and", "&&").Replace("OR", "||").Replace("or", "||");
resultType = "bool";
}
else if (calculation.CALCULATION_TYPE == 2) //数值运算
{
//{标签1}+3+{标签2}+4
resultType = "double";
}
else if (calculation.CALCULATION_TYPE == 3) //字符运算
{
//{标签1}+"123"
}
else if (calculation.CALCULATION_TYPE == 12) //条件数值运算
{
//{标签1}==3:{标签2}+1;{标签1}==4:{标签2}+2;{标签1}==5:{标签2}+3
resultType = "double";
List <string> exps = code.Split(';').ToList();
string temp = "";
foreach (var exp1 in exps)
{
if (exp1.Split(':').Length < 2)
{
continue;
}
temp += " if (" + exp1.Split(':')[0] + ") { return (" + exp1.Split(':')[1] + "); } \r\n";
}
temp += " return 0; \r\n";
code = temp;
}
else if (calculation.CALCULATION_TYPE == 13) //条件字符运算
{
//{标签1}==3:{标签1}+"123";{标签1}==4:{标签1}+"123"
List <string> exps = code.Split(';').ToList();
string temp = "";
foreach (var exp1 in exps)
{
if (exp1.Split(':').Length < 2)
{
continue;
}
temp += " if (" + exp1.Split(':')[0] + ") { return (" + exp1.Split(':')[1] + ").ToString(); } \r\n";
}
temp += " return \"\"; \r\n";
code = temp;
}
else if (calculation.CALCULATION_TYPE == 100) //C#脚本
{
//支持C#语法，最后返回值（Double/String)
resultType = "string";
}
else //不支持的类型
{
code = $" return \"计算类型[{calculation.CALCULATION_TYPE}]，不支持的类型。\"; \r\n";
}
execCode += DynamicCode.BuildExecFunc(funcname, resultType, code, funcParam); //增加一个函数
index++;
FuncAndParamTagPKNO.Add(funcname, paramTas); //添加
}
execCode += "}\r\n";
#endregion
#region 编译代码
CodeDomProvider compiler = new CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters()
{
GenerateExecutable = false, GenerateInMemory = true,
};
cp.ReferencedAssemblies.Add("BFM.Common.Base.dll");
CompilerResults cr = compiler.CompileAssemblyFromSource(cp, execCode);
if (cr.Errors.HasErrors)
{
NetLog.Error("DeviceMonitor.ThreadAutoCalculation Invaild Code: :" + execCode);
}
dynamicCode = cr.CompiledAssembly.GetType(className); //获取
#endregion
}
if ((TagCalculations == null) || (!TagCalculations.Any()) || (dynamicCode == null) || (FuncAndParamTagPKNO.Count <= 0))
{
Thread.Sleep(500);
continue;
}
#region 获取值
index = 0;
foreach (FmsTagCalculation calculation in TagCalculations)
{
FmsAssetTagSetting tagResult = GetTagSettingById(calculation.RESULT_TAG_PKNO); //结果
if (tagResult == null)
{
continue;
}
if (FuncAndParamTagPKNO.Count < index)
{
break;
}
string funcName = FuncAndParamTagPKNO.Keys.ToList()[index];
var tagParms = FuncAndParamTagPKNO.Values.ToList()[index];
List <object> paramValues = new List <object>(); //参数值
foreach (var tagpkno in tagParms) //参数
{
object value = null;
FmsAssetTagSetting tagParam = GetTagSettingById(tagpkno.Key);
if (tagParam != null)
{
value = SafeConverter.SafeToStr(tagParam.CUR_VALUE);
//if ((calculation.CALCULATION_TYPE == 2) || (tagParam.VALUE_TYPE > 0 && tagParam.VALUE_TYPE < 20))
//{
// value = SafeConverter.SafeToDouble(tagParam.CUR_VALUE);
//}
//else
//{
// value = SafeConverter.SafeToStr(tagParam.CUR_VALUE);
//}
}
else
{
value = "";
}
paramValues.Add(value);
}
object obj = dynamicCode.InvokeMember(funcName,
BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod,
System.Type.DefaultBinder, null, paramValues.ToArray());
string newValue = ""; //新的计算结果
#region 更新结果
if (calculation.CALCULATION_TYPE == 1) //逻辑运算
{
newValue = SafeConverter.SafeToBool(obj) ? "1" : "0";
}
else
{
newValue = SafeConverter.SafeToStr(obj);
}
SaveData(tagResult.PKNO, newValue); //保存更新值
#endregion
index++;
}
#endregion
}
catch (Exception e)
{
NetLog.Error("DeviceMonitor.ThreadAutoCalculation error:", e);
}
Thread.Sleep(100);
}
}
public bool StartCurrentProgerss()
{
if (curProcess.PROCESS_STATE == 1) //准备完成，未开始执行
{
if (!string.IsNullOrEmpty(startCondition) && LimitConditions.Contains(startCondition)) //如果前面的Job存在需要判断该状态，则不执行当前的
{
string sErrorInfo = $"等待执行";
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
}
return(false);
}
#region 开始执行工序 共 5 步
string startCustomParam = ""; //开始执行的参数，增加到同步写入数据后面
/************ ！！！工序开始的条件！！！ ************/
#region 1. 检验当前执行的工序是否可以执行，启动条件
if (startTag != null) //启动条件为空则直接执行
{
string checkValue = startTag.CUR_VALUE.Split('|')[0]; //当前执行条件的结果
string startValue = curAction.START_CONDITION_VALUE; //开始条件
string[] startValues = startValue.Split('|'); //多个开启条件
if ((string.IsNullOrEmpty(checkValue)) || (!startValues.Contains(checkValue))) //当前值不是工序开始检测值
{
#region 条件不符合的 流程分支情况
if (curProcess.PROCESS_ACTION_TYPE == 4) //流程分支，不启用，直接往下运行
{
#region 直接完成当前工序
#region 第一道工序处理
if (bFirstProcess) //第一道工序
{
mesJobOrder.RUN_STATE = 20; //正在执行
mesJobOrder.ACT_START_TIME = DateTime.Now; //修改任务开始时间
mesJobOrder.PROCESS_INFO = "正常"; //生产执行信息
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
}
#endregion
curProcess.PROCESS_STATE = 10; //直接完成
curProcess.PROCESS_END_TYPE = 1;
curProcess.PROCESS_END_TIME = DateTime.Now;
curProcess.REMARK = "条件不满足，不启用流程分支，直接执行现有流程。";
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
return(false); //直接执行重新执行
#endregion
}
#endregion
#region 判断条件不满足
string sErrorInfo =
$"生产过程【{ctrolName}】开启条件【{startTag?.TAG_NAME}】不足，当前状态为【{checkValue}】,需要状态【{startValue}】";
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
}
if (!LimitConditions.Contains(startCondition))
{
LimitConditions.Add(startCondition); //起始条件不满足，则添加限制条件
}
return(false);
#endregion
}
}
#endregion
/************ ！！！工序开始的条件满足，直接执行！！！ ************/
Console.WriteLine($"========生产过程【{ctrolName}】开始条件【{startTag?.TAG_NAME}】满足，开始执行=======");
#region 2. 启动流程分支
if (curProcess.PROCESS_ACTION_TYPE == 4) //流程分支
{
string disableProcesses = curProcess.PROCESS_ACTION_PARAM1_VALUE; //禁用的流程
string enableProcesses = curProcess.PROCESS_ACTION_PARAM2_VALUE; //启用的流程
string stemp = $"触发流程分支.禁用流程[{disableProcesses}], 启用流程[{enableProcesses}]";
mesJobOrder.PROCESS_INFO = stemp; //生产执行信息
Console.WriteLine(stemp);
#region 启动流程分支
if (!string.IsNullOrEmpty(disableProcesses))
{
foreach (var disableP in disableProcesses.Split(';'))
{
MesProcessCtrol process = unFinishProcessCtrols.FirstOrDefault(c =>
c.PROCESS_INDEX == SafeConverter.SafeToInt(disableP, -1));
process.USE_FLAG = 0; //禁用
PServiceEvent?.Invoke(d => d.UpdateMesProcessCtrol(process));
}
}
if (!string.IsNullOrEmpty(enableProcesses))
{
foreach (var enableP in enableProcesses.Split(';'))
{
MesProcessCtrol process = unFinishProcessCtrols.FirstOrDefault(c =>
c.PROCESS_INDEX == SafeConverter.SafeToInt(enableP, -1));
process.USE_FLAG = 1; //启用
PServiceEvent?.Invoke(d => d.UpdateMesProcessCtrol(process));
}
}
#endregion
#region 更新数据
#region 加工控制
curProcess.PROCESS_STATE = 10; //直接完成
curProcess.PROCESS_END_TYPE = 1;
curProcess.PROCESS_START_TIME = DateTime.Now.AddMilliseconds(-100);
curProcess.PROCESS_END_TIME = DateTime.Now;
curProcess.REMARK = $"流程分支条件满足，启用流程分支，禁用流程[{disableProcesses}], 启用流程[{enableProcesses}]";
PServiceEvent?.Invoke(d => d.UpdateMesProcessCtrol(curProcess));
#endregion
#region Job处理
if (bFirstProcess) //第一道工序
{
mesJobOrder.RUN_STATE = 20; //正在执行
mesJobOrder.ACT_START_TIME = DateTime.Now; //修改任务开始时间
}
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
#endregion
DeviceMonitor.SetTagSettingValueById(curAction.START_CONDITION_TAG_PKNO, ""); //将检测结果置为空
//产品处理
if (productProcess != null)
{
productProcess.PRODUCT_STATE = curProcess.PROCESS_ACTION_TYPE; //当前状态
productProcess.LAST_UPDATE_DATE = DateTime.Now;
var process = productProcess;
PServiceEvent?.Invoke(d => d.UpdateMesProductProcess(process));
}
#endregion
return(false); //直接开启下一次流程
} //启动流程分支
#endregion
//增加限制条件
if (!string.IsNullOrEmpty(startCondition) &&
!LimitConditions.Contains(startCondition)) //未完成的任务需要增加开始条件
{
LimitConditions.Add(startCondition);
}
#region 3. 获取产品，第一道工序形成产品
if (bFirstProcess || (productProcess == null)) //第一道控制，且没有形成
{
string productPKNO = CBaseData.NewGuid();
productProcess = new MesProductProcess() //生成新的产品
{
PKNO = productPKNO,
COMPANY_CODE = CBaseData.BelongCompPKNO,
ITEM_PKNO = curProcess.ITEM_PKNO,
JOB_ORDER_PKNO = curProcess.JOB_ORDER_PKNO,
JOB_ORDER = curProcess.JOB_ORDER,
SUB_JOB_ORDER_NO = curProcess.SUB_JOB_ORDER_NO,
PRODUCT_CODE = TableNOHelper.GetNewNO("MesProductProcess.PRODUCT_CODE", "P"),
PRODUCT_POSITION = "", //当前位置
CUR_ROCESS_CTROL_PKNO = curProcess.PKNO, //当前过程
RAW_NUMBER = curProcess.PROCESS_QTY, //原料数量
PRODUCT_NUMBER = curProcess.COMPLETE_QTY, //完成数量
QUALIFIED_NUMBER = curProcess.QUALIFIED_QTY, //合格品数量
PALLET_NO = curProcess.PALLET_NO, //托盘号
PRODUCT_STATE = -1, //尚未开始
CREATION_DATE = DateTime.Now,
CREATED_BY = CBaseData.LoginNO,
LAST_UPDATE_DATE = DateTime.Now, //最后修改日期
USE_FLAG = 1,
REMARK = "", //备注
}; //生成新的产品
curProcess.CUR_PRODUCT_CODE_PKNO = productPKNO; //新产品编号
}
else
{
curProcess.CUR_PRODUCT_CODE_PKNO = firstProcess.CUR_PRODUCT_CODE_PKNO; //将所有的产品
}
#endregion
#region 4. 执行当前工序 => 向设备写入数据 写 3 个值
int ret = 0;
string error = "";
string tagPKNO = "";
string sTagValue = "";
bool bWriteSuccess = true; //写入设备成功标志
#region 4.1 写参数1
tagPKNO = curAction.EXECUTE_PARAM1_TAG_PKNO;
sTagValue = GetDynamicValue(curProcess.PROCESS_ACTION_PARAM1_VALUE);
if ((!string.IsNullOrEmpty(tagPKNO)) && (!string.IsNullOrEmpty(sTagValue)))
{
#region 多次重写
int iWrite = 0;
while (iWrite < ReWriteCount)
{
ret = DeviceMonitor.WriteTagToDevice(tagPKNO, sTagValue, out error);
if (ret == 0)
{
Thread.Sleep(100); //写入成功后暂停
break;
}
iWrite++;
Thread.Sleep(100);
}
#endregion
if (ret == 10) //写入设备失败
{
string sErrorInfo = $"向设备写入参数1失败。错误为：{error}"; //生产执行信息
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
}
Console.WriteLine(sErrorInfo);
return(false);
}
if (ret == 0)
{
bWriteSuccess = true; //写入成功
}
}
#endregion
#region 4.2 写参数2
tagPKNO = curAction.EXECUTE_PARAM2_TAG_PKNO;
sTagValue = GetDynamicValue(curProcess.PROCESS_ACTION_PARAM2_VALUE);
if ((!string.IsNullOrEmpty(tagPKNO)) && (!string.IsNullOrEmpty(sTagValue)))
{
#region 多次重写
int iWrite = 0;
while (iWrite < ReWriteCount)
{
ret = DeviceMonitor.WriteTagToDevice(tagPKNO, sTagValue, out error);
if (ret == 0)
{
Thread.Sleep(100); //写入成功后暂停
break;
}
iWrite++;
Thread.Sleep(100);
}
#endregion
if (ret == 10) //写入设备失败
{
string sErrorInfo = $"向设备写入参数2失败。错误为：{error}"; //生产执行信息
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
}
Console.WriteLine(sErrorInfo);
return(false);
}
if (ret == 0)
{
bWriteSuccess = true; //写入成功
}
}
#endregion
#region 4.3 写执行
tagPKNO = curAction.EXECUTE_TAG_PKNO;
sTagValue = GetDynamicValue(curAction.EXECUTE_WRITE_VALUE) +
"|" + (string.IsNullOrEmpty(curProcess.PROCESS_ACTION_PARAM1_VALUE) ? "0" : curProcess.PROCESS_ACTION_PARAM1_VALUE) +
"|" + (string.IsNullOrEmpty(curProcess.PROCESS_ACTION_PARAM2_VALUE) ? "0" : curProcess.PROCESS_ACTION_PARAM2_VALUE) +
"|" + (string.IsNullOrEmpty(startCustomParam) ? "0" : startCustomParam);
if ((!string.IsNullOrEmpty(tagPKNO)) && (!string.IsNullOrEmpty(sTagValue.Replace("|", ""))))
{
#region 多次重写
int iWrite = 0;
while (iWrite < ReWriteCount)
{
ret = DeviceMonitor.WriteTagToDevice(tagPKNO, sTagValue, out error);
if (ret == 0)
{
//Thread.Sleep(100); //写入成功后暂停，最后不需要
break;
}
iWrite++;
Thread.Sleep(100);
}
#endregion
if (ret == 10) //写入设备失败
{
string sErrorInfo = $"向设备写入开始动作值失败。错误为：{error}"; //生产执行信息
if (mesJobOrder.PROCESS_INFO != sErrorInfo)
{
mesJobOrder.PROCESS_INFO = sErrorInfo; //生产执行信息
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
}
Console.WriteLine(sErrorInfo);
return(false);
}
if (ret == 0)
{
bWriteSuccess = true; //写入成功
}
}
#endregion
if (bWriteSuccess)
{
Console.WriteLine("给设备发送指令成功.开始进行执行" +
(string.IsNullOrEmpty(curProcess.SUB_JOB_ORDER_NO)
? curProcess.JOB_ORDER_PKNO
: curProcess.SUB_JOB_ORDER_NO)); //给设备发送动作指令成功
}
#endregion
#region 5. 更新数据 共更新 4 个模块
#region 5.1 加工控制
curProcess.PROCESS_STATE = 2; //正在执行
curProcess.PROCESS_START_TYPE = 1; //自动开始
curProcess.PROCESS_START_TIME = DateTime.Now;
PServiceEvent?.Invoke(d => d.UpdateMesProcessCtrol(curProcess));
#endregion
#region 5.2 业务相关处理
if (curProcess.PROCESS_ACTION_TYPE == 11) //开始 出库
{
mesJobOrder.ONLINE_QTY = curProcess.PROCESS_QTY; //在线数量
}
if (bFirstProcess) //第一道工序，新增产品信息
{
PServiceEvent?.Invoke(s => s.AddMesProductProcess(productProcess));
}
string sError = "";
string result = DeviceProcessControl.BeginCurBusiness(curProcess, ref sError); //开始当前控制的业务
if (result != "OK")
{
mesJobOrder.PROCESS_INFO = $"业务开始执行发生错误，写入数据库错误! 具体:{sError}";
}
#endregion
#region 5.3 Job处理
if (bFirstProcess) //第一道工序
{
mesJobOrder.RUN_STATE = 20; //正在执行
mesJobOrder.ACT_START_TIME = DateTime.Now; //修改任务开始时间
}
PServiceEvent?.Invoke(d => d.UpdateMesJobOrder(mesJobOrder));
#endregion
#region 5.4 将开始和结束条件 置空
DeviceMonitor.SetTagSettingValueById(curAction.START_CONDITION_TAG_PKNO, ""); //将检测结果置为空
FmsAssetTagSetting finishTag = DeviceMonitor.GetTagSettingById(curAction.FINISH_CONDITION_TAG_PKNO);
if (finishTag != null)
{
if (finishTag.SAMPLING_MODE == 11)
{
finishTag.SAMPLING_MODE = 10; //按照条件开启
}
DeviceMonitor.SetTagSettingValue(finishTag, "");
}
#endregion
#endregion
#endregion
if (startTag != null)
{
FMSControlService.iConditionStartAddPause = 500; //按条件启动后增加的延时
}
FMSControlService.bStart = true; //本次订单已经启动过了
}
return(true);
}
