/// <summary>
/// 执行复位动作
/// </summary>
protected override void ExecuteReset()
{
string errorInfo;
_Clamp(false); //打开夹爪
_OptPushCylinder(false); //降下推料气缸
//等待检测Z轴避位完成
if (!WaitSPBoolByAliasName(GPN_DetectAvoid, true, out errorInfo))
{
ExitWork(WorkExitCode.Exception, "等待检测Z轴避位信号失败:" + errorInfo);
}
if (!AxisHomeByAlias(DevAN_AxisEject, out errorInfo))
{
ExitWork(WorkExitCode.Exception, errorInfo);
}
JFWorkCmdResult wcr = WaitAxisHomeDoneByAlias(DevAN_AxisEject);
if (wcr != JFWorkCmdResult.Success)
{
ExitWork(WorkExitCode.Exception, "等待轴：" + DevAN_AxisEject + " 归零运动失败，Ret = " + wcr);
}
if (STWorkMode == StationThreadWorkMode.Normal)
{
ChangeCS(STStatus.开始运行);
}
}
/// <summary>
/// 工站归零
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void toolStripMenuItemReset_Click(object sender, EventArgs e)
{
if (null == _station)
{
MessageBox.Show("无效操作，工站未设置");
return;
}
JFWorkStatus ws = _station.CurrWorkStatus;
if (ws == JFWorkStatus.Running || ws == JFWorkStatus.Pausing || ws == JFWorkStatus.Interactiving)
{
JFTipsDelayClose.Show("无效操作，工站当前正在运行:" + ws, 1);
return;
}
JFWorkCmdResult ret = _station.Reset();
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("启动复位失败,错误代码:" + ret);
}
else
{
ShowTips("操作信息:复位已启动");
JFTipsDelayClose.Show("复位已启动", 1);
}
}
/// <summary>
/// 开始单工站运行
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void toolStripMenuItemStart_Click(object sender, EventArgs e)
{
if (null == _station)
{
MessageBox.Show("无效操作，工站未设置");
return;
}
JFWorkStatus ws = _station.CurrWorkStatus;
if (ws == JFWorkStatus.Running || ws == JFWorkStatus.Pausing || ws == JFWorkStatus.Interactiving)
{
JFTipsDelayClose.Show("无效操作，工站当前正在运行:" + ws, 1);
return;
}
//EnableStationMsgReceive = true;
JFWorkCmdResult ret = _station.Start();
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("启动工站失败,错误代码:" + ret);
//EnableStationMsgReceive = false;
}
else
{
JFTipsDelayClose.Show("操作信息:工站已启动", 1);
}
}
public override JFWorkCmdResult Start()
{
if (null == _axisChn)
{
ActionErrorInfo = "轴未设置";
return(JFWorkCmdResult.UnknownError);
}
string err;
if (!_axisChn.CheckAvalid(out err))
{
ActionErrorInfo = err;
return(JFWorkCmdResult.UnknownError);
}
_dev = _axisChn.Device() as IJFDevice_MotionDaq;
_md = _dev.GetMc(_ci.ModuleIndex);
_ci = _axisChn.CellInfo();
JFWorkCmdResult ret = base.Start();
if (ret != JFWorkCmdResult.Success)
{
ActionErrorInfo = "启动内部线程返回ErrorCode：" + ret;
}
return(ret);
}
/// <summary>
/// 工站恢复
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void toolStripMenuItemResume_Click(object sender, EventArgs e)
{
if (null == _station)
{
MessageBox.Show("无效操作，工站未设置");
return;
}
JFWorkStatus ws = _station.CurrWorkStatus;
if (!JFStationBase.IsWorkingStatus(ws))
{
JFTipsDelayClose.Show("无效操作，工站当前未运行:" + ws, 1);
return;
}
if (ws != JFWorkStatus.Pausing)
{
JFTipsDelayClose.Show("无效操作，工站当前非暂停状态:" + ws, 1);
return;
}
JFWorkCmdResult ret = _station.Resume(2000);
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("恢复运行失败,错误代码:" + ret);
}
else
{
ShowTips("操作信息:工站已恢复运行");
JFTipsDelayClose.Show("工站已恢复运行", 1);
}
}
/// <summary>
/// 结批操作
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void toolStripMenuItemEndBatch_Click(object sender, EventArgs e)
{
if (null == _station)
{
MessageBox.Show("无效操作，工站未设置");
return;
}
JFWorkStatus ws = _station.CurrWorkStatus;
if (!JFStationBase.IsWorkingStatus(ws))
{
JFTipsDelayClose.Show("无效操作，工站当前未运行:" + ws, 1);
return;
}
JFWorkCmdResult ret = _station.EndBatch(2000);
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("发送结批指令失败,错误代码:" + ret);
}
else
{
ShowTips("操作信息:结批指令已发送");
JFTipsDelayClose.Show("结批指令已发送", 1);
}
}
/// <summary>停止运行</summary>
public virtual bool Stop(out string errorInfo)
{
errorInfo = "Unknown Error";
//if (!IsStationRunning(WorkStatus))
//{
// errorInfo = "Success";
// return true;
//}
JFStationManager stationMgr = JFHubCenter.Instance.StationMgr;
string[] allEnableStationNames = stationMgr.AllEnabledStationNames();
if (null == allEnableStationNames || 0 == allEnableStationNames.Length)
{
errorInfo = "Success";
return(true);
}
foreach (string stationName in allEnableStationNames) // 先检查有没有正在运行的工站
{
IJFStation station = stationMgr.GetStation(stationName);
if (IsStationRunning(station.CurrWorkStatus))
{
JFWorkCmdResult ret = station.Stop(1000);
if (ret != JFWorkCmdResult.Success)
{
station.Abort();
}
}
}
WorkStatus = JFWorkStatus.CommandExit;
errorInfo = "Success";
return(true);
}
protected override bool ActionGenuine(out string errorInfo)
{
if (null == _station)
{
SetOutputParamValue(ON_Result, JFWorkCmdResult.UnknownError);
errorInfo = "工站未设置";
return(false);
}
string axisID = GetInitParamValue(PN_AxisName) as string;
bool isPositiveLimit = Convert.ToBoolean(GetInitParamValue(PN_IsPositiveLimit));
int timeoutMS = Convert.ToInt32(GetInitParamValue(PN_TimeoutMS));
if (!_station.ContainAxis(axisID))
{
SetOutputParamValue(ON_Result, JFWorkCmdResult.UnknownError);
errorInfo = "工站未包含轴:" + axisID;
return(false);
}
JFWorkCmdResult ret = _station.WaitAxis2Limit(axisID, isPositiveLimit, timeoutMS);
if (ret == JFWorkCmdResult.ActionError ||
ret == JFWorkCmdResult.StatusError ||
ret == JFWorkCmdResult.IllegalCmd ||
ret == JFWorkCmdResult.UnknownError)
{
SetOutputParamValue(ON_Result, ret);
errorInfo = "_station.WaitAxis2Limit return :" + ret;
return(false);
}
errorInfo = "Success";
return(true);
}
private void btStart_Click(object sender, EventArgs e)
{
JFWorkCmdResult ret = cmdWorker.Start();
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("启动失败，ret = " + ret.ToString());
}
}
/// <summary>
/// 夹住工件送料（单次）
/// </summary>
/// <param name="dis">送料行程</param>
/// <param name="errorInfo"></param先打开夹爪
/// <returns></returns>
public bool ClampEjectPiece(double dis, out string errorInfo, int timeoutMilliSeconds = -1)
{
if (!Clamp(false, out errorInfo)) //打开夹爪，
{
return(false);
}
//先移动到送料起始位置
if (!MoveToWorkPosition(WPN_EjectStart, out errorInfo))
{
return(false);
}
JFWorkCmdResult wcr = WaitMotionDoneByAlias(DevAN_AxisEject, timeoutMilliSeconds);
if (wcr != JFWorkCmdResult.Success)
{
errorInfo = "等待轴运动到抓料起始位置失败，ret = " + wcr;
return(false);
}
if (!Clamp(true, out errorInfo)) //闭合夹爪，
{
return(false);
}
if (!MoveAxisByAlias(DevAN_AxisEject, dis, false, out errorInfo)) //移动
{
return(false);
}
wcr = WaitMotionDoneByAlias(DevAN_AxisEject, timeoutMilliSeconds);
if (wcr != JFWorkCmdResult.Success)
{
errorInfo = "等待轴送料运动完成失败，ret = " + wcr;
}
//打开夹爪
if (!Clamp(false, out errorInfo))
{
return(false);
}
//返回待机位置
//if (!MoveToWorkPosition(WPN_Standby, out errorInfo))
// return false;
//wcr = WaitMotionDoneByAlias(DevAN_AxisEject, timeoutMilliSeconds);
//if (wcr != JFWorkCmdResult.Success)
//{
// errorInfo = "等待轴运动到待机位置失败，ret = " + wcr;
// return false;
//}
errorInfo = "Success";
return(true);
}
private void btSendCmd_Click(object sender, EventArgs e)
{
if (cbCmds.SelectedIndex < 0)
{
MessageBox.Show("请先选择需要发送的指令");
return;
}
JFWorkCmdResult ret = cmdWorker.SendCmd(cmdWorker.AllCmds[cbCmds.SelectedIndex], 1000);
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("发送指令失败，ret = " + ret.ToString());
}
}
private void btReset_Click(object sender, EventArgs e)
{
if (_station == null)
{
MessageBox.Show("归零操作失败！工站未设置/空值");
return;
}
JFWorkStatus ws = _station.CurrWorkStatus;
if (ws == JFWorkStatus.Running || ws == JFWorkStatus.Pausing || ws == JFWorkStatus.Interactiving)
{
MessageBox.Show("归零操作失败！工站当前正在运行");
return;
}
JFWorkCmdResult ret = _station.Reset();
}
//上升/下降 推料气缸
public bool OptPushCylinder(bool isUp, out string errorInfo, int timeoutMilliseconds = -1)
{
if (!SetDOAlias(DevAN_DOPushCldCtrl, isUp, out errorInfo))
{
ExitWork(WorkExitCode.Exception, errorInfo);
}
JFWorkCmdResult wcr = WaitDIAlias(DevAN_DIPushCldUp, isUp, out errorInfo, timeoutMilliseconds);
if (wcr != JFWorkCmdResult.Success)
{
ExitWork(WorkExitCode.Exception, errorInfo);
}
errorInfo = "Success";
return(true);
}
/// <summary>
/// 停止工站日志记录/显示
/// 在程序退出前调用
/// </summary>
public void Stop()
{
string errorInfo;
MainStation.Stop(out errorInfo);
string[] stationNames = AllStationNames();
if (null != stationNames)
{
foreach (string stationName in stationNames)
{
IJFStation station = GetStation(stationName);
if (IsStationRunning(station))
{
JFWorkCmdResult ret = station.Stop(1000);
if (ret != JFWorkCmdResult.Success)
{
//日后可能添加强制关闭的系统日志...
station.Abort();
}
}
}
}
JFLoggerManager.Instance.Stop();
StopShowStationLog();
if (null != stationNames)
{
foreach (string stationName in stationNames)
{
IJFStation station = GetStation(stationName);
station.WorkStatusChanged -= StationWorkStatusChanged;
station.CustomStatusChanged -= StationCustomStatusChanged;
if (station is JFCmdWorkBase)
{
(station as JFCmdWorkBase).WorkMsg2Outter -= StationTxtMsg;
}
if (station is JFStationBase)
{
(station as JFStationBase).EventCustomizeMsg -= StationCustomizeMsg;
(station as JFStationBase).EventProductFinished -= StationProductFinished;
}
}
}
Thread.Sleep(2000);
}
/// <summary>
/// 单步调试动作流
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btStep_Click(object sender, EventArgs e)
{
if (null == _methodFlow)
{
MessageBox.Show("无效操作！动作流对象未设置");
return;
}
if (_methodFlow.Count == 0)
{
MessageBox.Show("无效操作！流程中没有动作节点");
return;
}
if (_methodFlow.CurrStep == _methodFlow.Count - 1)
{
MessageBox.Show("无效操作！当前动作流已执行到结尾");
return;
}
if (_methodFlow.IsWorking())
{
if (_methodFlow.RunningMode != JFMethodFlow.RunMode.Step)
{
MessageBox.Show("正在连续运行，不能单步调试");
return;
}
JFWorkCmdResult ret = _methodFlow.Step();
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("发送单步指令失败，错误代码 = " + ret);
return;
}
}
else //当前未运行
{
JFWorkCmdResult ret = _methodFlow.Step();
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("启动单步调试失败,错误代码:" + ret);
return;
}
}
}
/// <summary>
/// 打开/关闭 夹爪气缸
/// </summary>
/// <param name="isClamp"></param>
/// <returns></returns>
public bool Clamp(bool isClamp, out string errorInfo, int timeoutMilliseconds = 5000)
{
string errInfo;
if (!SetDOAlias(DevAN_DOEjectCldCtrl, !isClamp, out errInfo))
{
errorInfo = isClamp ? "夹紧" : "松开" + "夹爪气缸失败,ErrorInfo:" + errInfo;
return(false);
}
JFWorkCmdResult wcr = WaitDIAlias(DevAN_DIEjectCldOpen, !isClamp, out errInfo, timeoutMilliseconds);
if (wcr != JFWorkCmdResult.Success)
{
errorInfo = isClamp ? "夹紧" : "松开" + "夹爪气缸失败,ErrorInfo:" + errInfo;
return(false);
}
errorInfo = "Success";
return(true);
}
private void btPause_Click(object sender, EventArgs e)
{
//if(_methodFlow.CurrWorkStatus == JFWorkStatus.AbortExit ||
// _methodFlow.CurrWorkStatus == JFWorkStatus.CommandExit ||
// _methodFlow.CurrWorkStatus == JFWorkStatus.ErrorExit ||
// _methodFlow.CurrWorkStatus == JFWorkStatus.ExceptionExit ||
// _methodFlow.CurrWorkStatus == JFWorkStatus.NormalEnd ||
// _methodFlow.CurrWorkStatus == JFWorkStatus.UnStart)
//{
// MessageBox.Show("暂停操作失败，工作流当前未运行");
// return;
//}
JFWorkCmdResult ret = _methodFlow.Pause(2000);
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("暂停失败：ErrorCode = " + ret);
}
}
protected override bool ActionGenuine(out string errorInfo)
{
if (_station == null)
{
errorInfo = "工站未设置";
return(false);
}
string aliasName = GetInitParamValue(PN_AliasName) as string;
bool tgtVal = Convert.ToBoolean(GetInitParamValue(PN_TargetVal));
int timeoutMilSec = Convert.ToInt32(GetInitParamValue(PN_TimeoutMilSec));
JFWorkCmdResult ret = _station.WaitSPBoolAliasInMethodFlow(aliasName, tgtVal, out errorInfo, timeoutMilSec);
SetOutputParamValue(ON_Result, ret);
if (ret == JFWorkCmdResult.Success || ret == JFWorkCmdResult.Timeout)
{
return(true);
}
return(false);
}
public virtual JFWorkCmdResult Stop(int timeoutMilliseconds = -1)
{
lock (accessLocker)
{
JFWorkCmdResult ret = JFWorkCmdResult.UnknownError;
Monitor.Enter(WorkStatusLocker);
{
if (!IsWorking())
{
Monitor.Exit(WorkStatusLocker);
return(JFWorkCmdResult.Success);
}
ret = _SendCmd(CommandStop, timeoutMilliseconds);
}
Monitor.Exit(WorkStatusLocker);
//if (ret == JFWorkCmdResult.Success)
// thread.Join();
return(ret);
}
}
/// <summary>
/// 执行方法流
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btAction_Click(object sender, EventArgs e)
{
if (null == _methodFlow)
{
MessageBox.Show("无效操作！动作流对象未设置");
return;
}
if (0 == _methodFlow.Count)
{
MessageBox.Show("无效操作！动作流中没有方法节点");
return;
}
JFWorkCmdResult ret = JFWorkCmdResult.UnknownError;
if (_methodFlow.CurrWorkStatus == JFWorkStatus.Pausing)
{
ret = _methodFlow.Resume(2000);
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show("恢复运行失败，错误代码 = " + ret);
return;
}
ShowTips("已恢复运行");
return;
}
if (_methodFlow.CurrWorkStatus == JFWorkStatus.Running ||
_methodFlow.CurrWorkStatus == JFWorkStatus.Interactiving)//当前正在运行
{
ShowTips("无效操作，工作流正在运行");
return;
}
UpdatePoolValues();
ret = _methodFlow.Start();
if (ret != JFWorkCmdResult.Success)
{
MessageBox.Show(" 启动工作流失败,错误代码:" + ret);
return;
}
}
/// <summary>从暂停中恢复运行</summary>
public virtual bool Resume(out string errorInfo)
{
errorInfo = "Unknown Error";
if (WorkStatus == JFWorkStatus.Running)
{
errorInfo = "当前正在运行！恢复运行指令将被忽略";
return(true);
}
if (WorkStatus != JFWorkStatus.Pausing)
{
errorInfo = "当前状态 = " + WorkStatus + ",不能响应恢复运行指令";
return(false);
}
JFStationManager stationMgr = JFHubCenter.Instance.StationMgr;
string[] allEnableStationNames = stationMgr.AllEnabledStationNames();
if (null == allEnableStationNames || 0 == allEnableStationNames.Length)
{
errorInfo = "无使能工站";
return(false);
}
foreach (string sn in allEnableStationNames)
{
IJFStation station = stationMgr.GetStation(sn);
JFWorkCmdResult ret = station.Resume(1000);
if (ret != JFWorkCmdResult.Success)
{
errorInfo = "工站:" + station.Name + "恢复运行失败:" + ret.ToString();
return(false);
}
}
errorInfo = "Success";
WorkStatus = JFWorkStatus.Running;
return(true);
}
/// <summary>
/// 停止单工站运行
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void toolStripMenuItemStop_Click(object sender, EventArgs e)
{
if (null == _station)
{
MessageBox.Show("无效操作，工站未设置");
return;
}
JFWorkCmdResult ret = _station.Stop(2000);
if (ret != JFWorkCmdResult.Success)
{
if (DialogResult.OK == MessageBox.Show(" 停止操作失败，错误代码:" + ret + "\n是否强制终止？", "警告", MessageBoxButtons.OKCancel, MessageBoxIcon.Error))
{
_station.Abort();
JFTipsDelayClose.Show("工站已强制停止！", 2);
}
}
else
{
JFTipsDelayClose.Show("工站已停止！", 2);
}
}
/// <summary>暂停</summary>
public virtual bool Pause(out string errorInfo)
{
errorInfo = "Unknown Error";
if (WorkStatus != JFWorkStatus.Running)
{
errorInfo = "设备当前状态:" + WorkStatus.ToString();
return(false);
}
if (WorkStatus == JFWorkStatus.Pausing)
{
errorInfo = "Success";
return(true);
}
JFStationManager stationMgr = JFHubCenter.Instance.StationMgr;
string[] allEnableStationNames = stationMgr.AllEnabledStationNames();
if (null == allEnableStationNames || 0 == allEnableStationNames.Length)
{
errorInfo = "无使能工站";
return(false);
}
foreach (string sn in allEnableStationNames)
{
IJFStation station = stationMgr.GetStation(sn);
JFWorkCmdResult ret = station.Pause(-1);
if (ret != JFWorkCmdResult.Success)
{
errorInfo = "工站:" + station.Name + " 暂停失败:" + ret.ToString();
return(false);
}
}
WorkStatus = JFWorkStatus.Pausing;
errorInfo = "Success";
return(true);
}
/// <summary>
/// 夹住工件送料（单次）
/// </summary>
/// <param name="dis">送料行程</param>
/// <param name="errorInfo"></param>
/// <returns></returns>
public bool ClampFeedPiece(double dis, out string errorInfo, int timeoutMilliSeconds = -1)
{
if (!Clamp(true, out errorInfo))
{
return(false);
}
if (!MoveAxisByAlias(DevAN_AxisFeed, dis, false, out errorInfo))
{
return(false);
}
JFWorkCmdResult wcr = WaitMotionDoneByAlias(DevAN_AxisFeed, timeoutMilliSeconds);
if (wcr != JFWorkCmdResult.Success)
{
errorInfo = "等待轴送料运动完成失败，ret = " + wcr;
}
if (!Clamp(false, out errorInfo))
{
return(false);
}
//if (!MoveAxisByAlias(DevAN_AxisFeed, -dis, false, out errorInfo))
// return false;
if (!MoveToWorkPosition(WPN_Standby, out errorInfo))
{
return(false);
}
wcr = WaitMotionDoneByAlias(DevAN_AxisFeed, timeoutMilliSeconds);
if (wcr != JFWorkCmdResult.Success)
{
errorInfo = "等待轴回程运动完成失败，ret = " + wcr;
return(false);
}
errorInfo = "Success";
return(true);
}
protected override bool ActionGenuine(out string errorInfo)
{
if (_station == null)
{
errorInfo = "工站未设置/空值";
SetOutputParamValue(ON_Result, JFWorkCmdResult.UnknownError);
return(false);
}
string axisID = GetInitParamValue(PN_AxisName) as string;
int timeoutMS = Convert.ToInt32(GetInitParamValue(PN_TimeoutMS));
if (!_station.ContainAxis(axisID))
{
errorInfo = "工站未包含轴ID:\"" + axisID + "\"";
SetOutputParamValue(ON_Result, JFWorkCmdResult.UnknownError);
return(false);
}
JFWorkCmdResult ret = _station.WaitMotionDone(axisID, timeoutMS);
SetOutputParamValue(ON_Result, ret);
errorInfo = "Success";
return(true);
}
Dictionary <IJFStation, FormSingleStationTest> _dctTestingForms = new Dictionary <IJFStation, FormSingleStationTest>(); //参与当前测试的
/// <summary>
/// 启动所有选中的工站
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btStart_Click(object sender, EventArgs e)
{
if (_isTesting)
{
MessageBox.Show("无效操作，当前测试正在运行");
return;
}
string[] willTestStationNames = TestStationNames();
if (null == willTestStationNames || 0 == willTestStationNames.Length)
{
MessageBox.Show("请先选择参与测试运行的工站！\n菜单->启动测试");
return;
}
JFStationManager mgr = JFHubCenter.Instance.StationMgr;
string[] allStationNames = mgr.AllStationNames();
List <string> runningStationNames = new List <string>(); //当前正在运行的工站
foreach (string s in allStationNames)
{
if (JFStationBase.IsWorkingStatus(mgr.GetStation(s).CurrWorkStatus))
{
runningStationNames.Add(s);
}
}
if (runningStationNames.Count > 0)
{
string info = "以下工站正在运行:\n";
foreach (string s in runningStationNames)
{
info += s + "\n";
}
info += "是否继续？";
if (DialogResult.Cancel == MessageBox.Show(info, "警告", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning))
{
return;
}
}
_isTesting = true;
//mgr.EventStationWorkStatusChanged += OnStationWorkStatusChanged;
_dctTestingForms.Clear();
string Tipsinfo = "已启动工站:\n";
foreach (string s in willTestStationNames)
{
IJFStation station = mgr.GetStation(s);
_dctTestingForms.Add(station, _dctStationForms[station]);
//_dctStationForms[station].EnableStationMsgReceive = true;
JFWorkCmdResult ret = station.Start();
if (ret != JFWorkCmdResult.Success) //启动工站失败
{
//_dctStationForms[station].EnableStationMsgReceive = false;
foreach (KeyValuePair <IJFStation, FormSingleStationTest> kv in _dctTestingForms)
{
if (kv.Key.Stop(500) != JFWorkCmdResult.Success)
{
kv.Key.Abort();
}
}
_isTesting = false;
MessageBox.Show("启动工站:" + station.Name + "失败,ErrorCode = " + ret);
return;
}
Tipsinfo += s + "\n";
JFTipsDelayClose.Show(Tipsinfo, 2);
btReset.Enabled = false;
btResume.Enabled = true;
btPause.Enabled = true;
}
}
public virtual bool Start(out string errorInfo)//开始运行
{
errorInfo = "Unknown Error";
if (IsAlarming)
{
errorInfo = "当前处于报警状态";
return(false);
}
if (IsStationRunning(WorkStatus))
{
errorInfo = "Success";
return(true);
}
JFDLAFRecipeManager rm = JFHubCenter.Instance.RecipeManager as JFDLAFRecipeManager;
if (null == rm)
{
errorInfo = "配方管理器未创建！";
return(false);
}
if (!rm.IsInitOK)
{
errorInfo = "配方管理器初始化未完成,ErrorInfo:" + rm.GetInitErrorInfo();
return(false);
}
JFStationManager stationMgr = JFHubCenter.Instance.StationMgr;
string[] allEnableStationNames = stationMgr.AllEnabledStationNames();
if (null == allEnableStationNames || 0 == allEnableStationNames.Length)
{
errorInfo = "不存在使能的工站";
return(false);
}
foreach (string stationName in allEnableStationNames) // 先检查有没有正在运行的工站
{
IJFStation station = stationMgr.GetStation(stationName);
if (IsStationRunning(station.CurrWorkStatus))
{
errorInfo = "启动失败，工站:" + station.Name + " 当前状态:" + station.CurrWorkStatus.ToString();
return(false);
}
}
///检查当前RecipeID 和 LotID
if (string.IsNullOrEmpty(CurrRecipeID))
{
errorInfo = "启动失败:当前产品ID未设置";
return(false);
}
string[] allRecipeIDs = rm.AllRecipeIDsInCategoty(SCN_CategotyProd);
if (null == allRecipeIDs || !allRecipeIDs.Contains(CurrRecipeID))
{
errorInfo = "启动失败，当前产品ID:" + CurrRecipeID + " 在配方管理器中不存在";
return(false);
}
if (string.IsNullOrEmpty(CurrLotID))
{
errorInfo = "启动失败:当前批次号未设置！";
return(false);
}
int failedIndex = -1; //启动失败的工站号
foreach (string stationName in allEnableStationNames)
{
IJFStation station = stationMgr.GetStation(stationName);
JFWorkCmdResult ret = station.Start();
if (ret != JFWorkCmdResult.Success)
{
errorInfo = "工站:" + station.Name + " 启动失败,Error:" + ret.ToString();
break;
}
}
if (failedIndex > -1)
{
for (int i = 0; i < failedIndex + 1; i++)
{
IJFStation station = stationMgr.GetStation(allEnableStationNames[i]);
if (JFWorkCmdResult.Success != station.Stop(100))
{
station.Abort();
}
}
return(false);
}
WorkStatus = JFWorkStatus.Running;
errorInfo = "Success";
return(true);
}
/// <summary>
/// 向工站发送一条指令（包含 开始/停止/暂停/恢复/结批 和用户自定义指令）
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btSendCmd_Click(object sender, EventArgs e)
{
int selIndex = cbCmds.SelectedIndex;
if (selIndex < 0)
{
JFTipsDelayClose.Show("请选择需要发送的指令", 2);//MessageBox.Show("请选择需要发送的指令");
return;
}
JFWorkCmdResult cmdRet = JFWorkCmdResult.UnknownError;
if (AllowedStartStopCmd)
{
if (selIndex < 5) //开始/暂停/恢复/结批/停止
{
switch (selIndex)
{
case 0: cmdRet = _station.Start(); break;
case 1: cmdRet = _station.Pause(1000); break;
case 2: cmdRet = _station.Resume(1000); break;
case 3: cmdRet = _station.EndBatch(1000); break;
case 4: cmdRet = _station.Stop(1000); break;
}
}
else
{
int cmdIndex = selIndex - 5;
cmdRet = _station.SendCmd(_station.AllCmds[cmdIndex], 1000);
}
}
else
{
if (selIndex < 2) //暂停/恢复
{
switch (selIndex)
{
case 0: cmdRet = _station.Pause(1000); break;
case 1: cmdRet = _station.Resume(1000); break;
}
}
else
{
int cmdIndex = selIndex - 2;
cmdRet = _station.SendCmd(_station.AllCmds[cmdIndex], 1000);
}
}
string errInfo = "";
switch (cmdRet)
{
case JFWorkCmdResult.UnknownError: // = -1, //发生未定义的错误
errInfo = "未知错误";
break;
case JFWorkCmdResult.Success: // = 0, //指令执行成功
errInfo = "指令执行成功";
break;
case JFWorkCmdResult.IllegalCmd: //,//不支持的非法指令
errInfo = "不支持的非法指令";
break;
case JFWorkCmdResult.StatusError: //, //工作状态（包括用户自定义状态）不支持当前指令 ，（向未运行的线程发送Resume指令）
errInfo = "当前状态不支持该指令";
break;
case JFWorkCmdResult.ActionError: //, //指令执行失败
errInfo = "执行失败";
break;
case JFWorkCmdResult.Timeout: //,//线程超时未响应
errInfo = "指令执行超时";
break;
}
if (cmdRet != JFWorkCmdResult.Success)
{
JFTipsDelayClose.Show("指令:" + cbCmds.Text + " 发送失败:" + errInfo, 3);
}
else
{
ShowTips("指令:" + cbCmds.Text + "发送完成");
}
}
//主动做流程
protected override void RunLoopInWork()
{
string errorInfo;
bool isSigON = false;
JFWorkCmdResult wcr = JFWorkCmdResult.UnknownError;
object obj = null;
switch (CurrCS)
{
//case STStatus.已停止: //不会出现在此处的状态
// break;
//case STStatus.复位://不会出现在此处的状态
// break;
case STStatus.开始运行:
_Clamp(false); //打开夹手
_OptPushCylinder(false); //降下推料气缸
//检测出料口是否有工件
if (!GetDIByAlias(DevAN_DIPieceInEject, out isSigON, out errorInfo))
{
ExitWork(WorkExitCode.Exception, errorInfo);
}
if (isSigON)
{
ExitWork(WorkExitCode.Exception, "出料口感应器检测到有信号，请清理残留料片！");
}
ChangeCS(STStatus.等待检测Z轴避位);
break;
case STStatus.等待检测Z轴避位: //归零时等待Z轴抬起后，再进行下一步动作
if (!WaitSPBoolByAliasName(GPN_DetectAvoid, true, out errorInfo))
{
ExitWork(WorkExitCode.Exception, errorInfo);
}
ChangeCS(STStatus.移动到待机位置);
break;
case STStatus.移动到待机位置:
_Clamp(false); //打开夹手
_OptPushCylinder(false); //降下推料气缸
if (!SetAxisMPSpeedByAlias(DevAN_AxisEject, _normalSpd, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
if (!MoveToWorkPosition(WPN_Standby, out errorInfo))
{
ExitWork(WorkExitCode.Exception, errorInfo);
}
if (WaitToWorkPosition(WPN_Standby, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
SetSPAliasValue(GPN_AllowedLoad, true); //告诉轨道上料站可以上料
SetSPAliasValue(GPN_EjectReady, true); //告诉下料仓准备接收
ChangeCS(STStatus.等待检测完成);
break;
case STStatus.等待检测完成:
SendMsg2Outter("等待检测工站视觉检测完成...");
if (!WaitSPBoolByAliasName(GPN_DetectDone, true, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
SetSPAliasValue(GPN_DetectDone, false);
SendMsg2Outter("等待检测Z轴到达避位...");
if (!WaitSPBoolByAliasName(GPN_DetectAvoid, true, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
ChangeCS(STStatus.等待下料仓准备好);
break;
case STStatus.等待下料仓准备好:
SendMsg2Outter("等待下料仓准备好...");
if (!WaitSPBoolByAliasName(GPN_UnloadReady, true, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
ChangeCS(STStatus.出料);
break;
case STStatus.出料: //轨道（自身）向检测位置送料
double clampDis = 0; //需要夹住工件往返运动的距离
double pushDis = 0; //最后一次退料的距离;
if (_ejectDis < _clampLength) //总行程
{
clampDis = _ejectDis; //只需要夹持一次就好
}
else
{
clampDis = _piece2HandEdge + 5; //预留退料间隙5mm
pushDis = _ejectDis - _piece2HandEdge;
}
if (!SetAxisMPSpeedByAlias(DevAN_AxisEject, _pushSpd, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
while (clampDis > _clampLength)
{
//往返运动一次
SendMsg2Outter("夹料距离:" + _clampLength);
_ClampEjectPiece(_clampLength);
clampDis -= _clampLength;
}
if (clampDis > 0) //最后一节不足一个行程的部分
{
SendMsg2Outter("夹料距离:" + clampDis);
_ClampEjectPiece(clampDis);
}
if (pushDis > 0) //闭合夹爪，推料到位
{
SendMsg2Outter("推料距离:" + pushDis);
_Clamp(false);
// 移动到推料起始位置
if (!MoveToWorkPosition(WPN_EjectStart, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
if (!WaitToWorkPosition(WPN_EjectStart, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
_OptPushCylinder(true); //抬起推料气缸
//设置推料速度
if (!SetAxisMPSpeedByAlias(DevAN_AxisEject, _pushSpd, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
if (!MoveAxisByAlias(DevAN_AxisEject, pushDis, false, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
SendMsg2Outter("开始推料入仓...");
while (true)
{
CheckCmd(CycleMilliseconds);
if (!GetDIByAlias(DevAN_DIPushObstruct, out isSigON, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
if (isSigON)
{
ExitWork(WorkExitCode.Exception, "推料入仓时卡料信号被触发...");
}
wcr = WaitMotionDoneByAlias(DevAN_AxisEject, CycleMilliseconds);
if (wcr == JFWorkCmdResult.Timeout)
{
continue;
}
else if (wcr == JFWorkCmdResult.Success)
{
SendMsg2Outter("推料入仓OK");
break;
}
else
{
ExitWork(WorkExitCode.Exception, "等待推料完成出错:ret = " + wcr);
}
}
}
_OptPushCylinder(false); //下降推料气缸
//回到待机位置
if (!MoveToWorkPosition(WPN_Standby, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
if (!WaitToWorkPosition(WPN_Standby, out errorInfo))
{
ExitWork(WorkExitCode.Error, errorInfo);
}
SetSPAliasValue(GPN_EjectDone, true); //通知下料仓 ， 送料完成
SetSPAliasValue(GPN_DetectDone, false);
SetSPAliasValue(GPN_AllowedLoad, true);
SetSPAliasValue(GPN_EjectReady, true);
ChangeCS(STStatus.等待检测完成);
break;
default:
ExitWork(WorkExitCode.Exception, "工作流程中未命中的Custom-Status:" + CurrCS.ToString());
break;
}
}
public virtual bool Start(out string errorInfo)//开始运行
{
errorInfo = "Unknown Error";
if (IsAlarming)
{
errorInfo = "当前处于报警状态";
return(false);
}
if (IsStationRunning(WorkStatus))
{
errorInfo = "Success";
return(true);
}
JFStationManager stationMgr = JFHubCenter.Instance.StationMgr;
string[] allEnableStationNames = stationMgr.AllEnabledStationNames();
if (null == allEnableStationNames || 0 == allEnableStationNames.Length)
{
errorInfo = "不存在使能的工站";
return(false);
}
foreach (string stationName in allEnableStationNames) // 先检查有没有正在运行的工站
{
IJFStation station = stationMgr.GetStation(stationName);
if (IsStationRunning(station.CurrWorkStatus))
{
errorInfo = "启动失败，工站:" + station.Name + " 当前状态:" + station.CurrWorkStatus.ToString();
return(false);
}
}
int failedIndex = -1; //启动失败的工站号
foreach (string stationName in allEnableStationNames)
{
IJFStation station = stationMgr.GetStation(stationName);
JFWorkCmdResult ret = station.Start();
if (ret != JFWorkCmdResult.Success)
{
errorInfo = "工站:" + station.Name + " 启动失败,Error:" + ret.ToString();
break;
}
}
if (failedIndex > -1)
{
for (int i = 0; i < failedIndex + 1; i++)
{
IJFStation station = stationMgr.GetStation(allEnableStationNames[i]);
if (JFWorkCmdResult.Success != station.Stop(100))
{
station.Abort();
}
}
return(false);
}
WorkStatus = JFWorkStatus.Running;
errorInfo = "Success";
return(true);
}
