using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Misc;
using FlyADBase;
using FLY.Thick.Base.Common;
using System.Diagnostics;
namespace FLY.Thick.Base.Server
{
public delegate void EndEventHandler(object obj, MiniGridEventArgs e);
/// <summary>
/// 只是来回走的逻辑，不包含数据处理
/// </summary>
public abstract class GM_ScanMotion : GM_Base
{
#region 成员变量
protected GSample gsample;
/// <summary>
/// 归0开始时间点，用于计算什么时候需要归0
/// </summary>
private TimeSpan orgStartTime;
/// <summary>
/// 使用timer.Elapsed 代替 DateTime.Now 使用
/// </summary>
private Stopwatch timer = new Stopwatch();
/// <summary>
/// 归原点间隔
/// </summary>
public int OrgInterval { get; set; }
/// <summary>
/// 扫描范围
/// </summary>
public int ScanStart { get; set; }
public int ScanEnd { get; set; }
public event EndEventHandler DataPosEvent;
public event EndEventHandler EndEvent;
public event EventHandler StartEvent;
public event EventHandler FinishEvent;
enum CTRLST
{
INIT = 0,//判断进入阶段
#region 归0 及 样品采集阶段
ORIGINWAIT = 2,//正在归0
FORWARD = 3,//前进到样品，或扫描结束位置
FORWAIT_1 = 4,//前进等待
FORWAIT_2 = 5,//前进结束，等待获取grid
BACKWARD = 8,//后退到温修，或扫描开始位置
BACKWAIT_1 = 9,//后退等待
BACKWAIT_2 = 10,//后退结束，等待获取grid
FORWAIT_SAMPLE = 11,//前进取样中
FORW_SAMPLE = 12,//前进取样
BACKWAIT_SAMPLE = 13,//后退取样中
BACKW_SAMPLE = 14,//后退取样
#endregion
#region 正常扫描阶段
SCAN_FORW = 20,//前进扫描
SCAN_FORWAIT = 21,//前进等待
SCAN_BACKW = 22,//后退扫描
SCAN_BACKWAIT = 23,//后退等待
#endregion
}
CTRLST state;
#endregion
public UInt32 Velocity { get; set; }
public GM_ScanMotion()
{
GMState = CTRL_STATE.SCAN;
ScanStart = -1;
ScanEnd = -1;
}
public virtual void Init(FlyAD7 flyad, GSample gsample)
{
base.Init(flyad);
this.gsample = gsample;
flyad.MiniGridEvent += (s, e) =>
{
if ((state == CTRLST.FORWAIT_1)
|| (state == CTRLST.BACKWAIT_1)
|| (state == CTRLST.SCAN_FORWAIT)
|| (state == CTRLST.SCAN_BACKWAIT))
{
DataPosEvent?.Invoke(this, e);
}
};
}
protected virtual bool Start2(int start, int end)
{
ScanStart = start;
ScanEnd = end;
timer.Restart();
orgStartTime = TimeSpan.FromMinutes(-OrgInterval);
state = CTRLST.INIT;
if (gsample != null)
gsample.Reset(ScanStart, ScanEnd);
StartEvent?.Invoke(this, null);
return true;
}
public override void Stop()
{
timer.Stop();
FinishEvent?.Invoke(this, null);
base.Stop();
}
bool WaitFinish(ref CTRLST src, CTRLST next)
{
switch (mFlyAD.DriveStatus)
{
case DRIVE_MAN_STATUS.STOP://完成任务
case DRIVE_MAN_STATUS.LIMIT:
{
src = next;
return true;
} break;
case DRIVE_MAN_STATUS.STOP_MANUAL://异常
{
NotifyError(ERRNO_Running_Manual);
Stop(); return false;
} break;
}
return false;
}
protected override void OnPoll()
{
switch (state)
{
case CTRLST.INIT:
{
if (IsOrging())
{
mFlyAD.Origin();
state = CTRLST.ORIGINWAIT;
}
else {
state = CTRLST.SCAN_FORW;
}
}
break;
case CTRLST.ORIGINWAIT:
{
WaitFinish(ref state, CTRLST.FORWARD);
} break;
case CTRLST.FORWARD:
{
int to = ScanEnd;
int b, e;
if (gsample.GetSampleRange(Misc.DIRECTION.FORWARD, out b, out e))
{
FlyADBase.MOTORTYPE motorType = mFlyAD.MotorType;
if (motorType == FlyADBase.MOTORTYPE.VF0)
{
//直接去到取样的位置
to = e;
}
else//要变速，分开两段
{
to = b;
}
}
mFlyAD.SetVelocity(Velocity);
mFlyAD.Runto(to);
state = CTRLST.FORWAIT_1;
} break;
case CTRLST.FORWAIT_1:
{
if (WaitFinish(ref state, CTRLST.FORWAIT_2))
FlushAD(DIRECTION.FORWARD);
} break;
case CTRLST.FORWAIT_2:
{
state = CTRLST.BACKWARD;
int b, e;
if (gsample.GetSampleRange(Misc.DIRECTION.FORWARD, out b, out e))
{
FlyADBase.MOTORTYPE motorType = mFlyAD.MotorType;
if (motorType == FlyADBase.MOTORTYPE.VF0)
{
//直接去到取样的位置
state = CTRLST.FORW_SAMPLE;
}
else//要变速，分开两段
{
mFlyAD.SetVelocity(gsample.Velocity);
mFlyAD.Runto(e);
state = CTRLST.FORWAIT_SAMPLE;
}
}
} break;
case CTRLST.FORWAIT_SAMPLE:
{
WaitFinish(ref state, CTRLST.FORW_SAMPLE);
} break;
case CTRLST.FORW_SAMPLE:
{
gsample.Do(Misc.DIRECTION.FORWARD);
state = CTRLST.BACKWARD;
} break;
case CTRLST.BACKWARD:
{
int to = ScanStart;
int b, e;
if (gsample.GetSampleRange(Misc.DIRECTION.BACKWARD, out b, out e))
{
FlyADBase.MOTORTYPE motorType = mFlyAD.MotorType;
if (motorType == FlyADBase.MOTORTYPE.VF0)
{
//直接去到取样的位置
to = b;
}
else//要变速，分开两段
{
to = e;
}
}
mFlyAD.SetVelocity(Velocity);
mFlyAD.Runto(to);
state = CTRLST.BACKWAIT_1;
} break;
case CTRLST.BACKWAIT_1:
{
if (WaitFinish(ref state, CTRLST.BACKWAIT_2))
FlushAD(DIRECTION.BACKWARD);
} break;
case CTRLST.BACKWAIT_2:
{
int b, e;
if (gsample.GetSampleRange(Misc.DIRECTION.BACKWARD, out b, out e))
{
FlyADBase.MOTORTYPE motorType = mFlyAD.MotorType;
if (motorType == FlyADBase.MOTORTYPE.VF0)
{
//直接去到取样的位置
state = CTRLST.BACKW_SAMPLE;
}
else//要变速，分开两段
{
mFlyAD.SetVelocity(gsample.Velocity);
mFlyAD.Runto(b);
state = CTRLST.BACKWAIT_SAMPLE;
}
}
else {
//完成一次周期
if (!gsample.IsFailure())
orgStartTime = timer.Elapsed;
state = CTRLST.INIT;
}
} break;
case CTRLST.BACKWAIT_SAMPLE:
{
WaitFinish(ref state, CTRLST.BACKW_SAMPLE);
} break;
case CTRLST.BACKW_SAMPLE:
{
gsample.Do(Misc.DIRECTION.BACKWARD);
//完成一次周期
if (!gsample.IsFailure())
orgStartTime = timer.Elapsed;
state = CTRLST.INIT;
} break;
case CTRLST.SCAN_FORW:
{
int to = ScanEnd;
mFlyAD.SetVelocity(Velocity);
mFlyAD.Runto(to);
state = CTRLST.SCAN_FORWAIT;
}
break;
case CTRLST.SCAN_FORWAIT:
{
if (WaitFinish(ref state, CTRLST.SCAN_BACKW))
FlushAD(DIRECTION.FORWARD);
}
break;
case CTRLST.SCAN_BACKW:
{
int to = ScanStart;
mFlyAD.SetVelocity(Velocity);
mFlyAD.Runto(to);
state = CTRLST.SCAN_BACKWAIT;
}
break;
case CTRLST.SCAN_BACKWAIT:
{
if (WaitFinish(ref state, CTRLST.INIT))
FlushAD(DIRECTION.BACKWARD);
}
break;
}
}
private bool IsOrging()
{
if (OrgInterval > 0) {
if (timer.Elapsed >= (orgStartTime + TimeSpan.FromMinutes(OrgInterval)))
return true;
}
return false;
}
private bool IsOrgEnable()
{
if (OrgInterval > 0)
return true;
else
return false;
}
private void FlushAD(Misc.DIRECTION direction)
{
int pos1, pos2;
pos1 = ScanStart;
pos2 = ScanEnd;
int start_grid = pos1 / mFlyAD.PosOfGrid;
int end_grid = pos2 / mFlyAD.PosOfGrid;
if (start_grid < 0)
start_grid = 0;
int len = end_grid - start_grid + 1;
int[] dat;
mFlyAD.GetGrid(direction, start_grid, len, out dat);
if (EndEvent != null)
{
EndEvent(this, new MiniGridEventArgs()
{
grid_start = start_grid,
direction = direction,
posOfGrid = mFlyAD.PosOfGrid,
buf = dat
});
}
}
}
/// <summary>
/// 只是来回走的逻辑，不包含数据处理
/// 0~posLen
/// </summary>
public abstract class GM_ScanMotion2 : GM_Base
{
#region 成员变量
int scanCnt;//扫描次数， 当为-1时，无限次扫描，>0时，有限次扫描
protected int ScanCnt
{
get
{
return scanCnt;
}
set
{
if (scanCnt != value)
{
scanCnt = value;
NotifyPropertyChanged("ScanCnt");
}
}
}
public event EndEventHandler DataPosEvent;
public event EndEventHandler EndEvent;
public event EventHandler StartEvent;
public event EventHandler FinishEvent;
enum CTRLST
{
/// <summary>
/// 准备动作:归0
/// </summary>
READY_ORIGIN = 1,
/// <summary>
/// 准备动作:正在归0
/// </summary>
READY_ORIGINWAIT = 2,
/// <summary>
/// 准备动作:后退到 0 脉冲
/// </summary>
READY_BACKW = 3,
/// <summary>
/// 准备动作:正在后退
/// </summary>
READY_BACKWAIT = 4,
/// <summary>
/// 前进到 机架总长
/// </summary>
SFORWARD = 5,
/// <summary>
/// 前进等待
/// </summary>
SFORWAIT_1 = 6,
/// <summary>
/// 前进结束，等待获取grid
/// </summary>
SFORWAIT_2 = 7,
/// <summary>
/// 后退到 0 脉冲
/// </summary>
SBACKWARD = 8,
/// <summary>
/// 后退等待
/// </summary>
SBACKWAIT_1 = 9,
/// <summary>
/// 后退结束，等待获取grid
/// </summary>
SBACKWAIT_2 = 10,
}
CTRLST state;
#endregion
public UInt32 Velocity { get; set; }
public GM_ScanMotion2()
{
GMState = CTRL_STATE.SCAN;
ScanCnt = -1;//无限扫描
state = CTRLST.READY_ORIGIN;
}
public override void Init(FlyAD7 flyad)
{
base.Init(flyad);
flyad.MiniGridEvent += (s, e) =>
{
if ((state == CTRLST.SFORWAIT_1) || (state == CTRLST.SBACKWAIT_1))
{
if (DataPosEvent != null)
DataPosEvent(this, e);
}
};
}
protected virtual void Start2()
{
state = CTRLST.READY_ORIGIN;
if (StartEvent != null)
StartEvent(this, null);
}
public override void Stop()
{
if (FinishEvent != null)
FinishEvent(this, null);
base.Stop();
}
bool WaitFinish(ref CTRLST src, CTRLST next)
{
switch (mFlyAD.DriveStatus)
{
case DRIVE_MAN_STATUS.STOP://完成任务
case DRIVE_MAN_STATUS.LIMIT:
{
src = next;
return true;
} break;
case DRIVE_MAN_STATUS.STOP_MANUAL://异常
{
NotifyError(ERRNO_Running_Manual);
Stop(); return false;
} break;
}
return false;
}
protected override void OnPoll()
{
switch (state)
{
case CTRLST.READY_ORIGIN:
{
mFlyAD.Origin();
state = CTRLST.READY_ORIGINWAIT;
} break;
case CTRLST.READY_ORIGINWAIT:
{
WaitFinish(ref state, CTRLST.READY_BACKW);
}break;
case CTRLST.READY_BACKW:
{
mFlyAD.SetVelocity(Velocity);
mFlyAD.RuntoMin();
state = CTRLST.READY_BACKWAIT;
} break;
case CTRLST.READY_BACKWAIT:
{
WaitFinish(ref state, CTRLST.SFORWARD);
} break;
case CTRLST.SFORWARD:
{
mFlyAD.SetVelocity(Velocity);
mFlyAD.RuntoMax();
state = CTRLST.SFORWAIT_1;
} break;
case CTRLST.SFORWAIT_1:
{
if (WaitFinish(ref state, CTRLST.SFORWAIT_2))
FlushAD(DIRECTION.FORWARD);
} break;
case CTRLST.SFORWAIT_2:
{
state = CTRLST.SBACKWARD;
} break;
case CTRLST.SBACKWARD:
{
mFlyAD.SetVelocity(Velocity);
mFlyAD.RuntoMin();
state = CTRLST.SBACKWAIT_1;
} break;
case CTRLST.SBACKWAIT_1:
{
if (WaitFinish(ref state, CTRLST.SBACKWAIT_2))
FlushAD(DIRECTION.BACKWARD);
} break;
case CTRLST.SBACKWAIT_2:
{
state = CTRLST.SFORWARD;
//扫描次数
if (ScanCnt > 0)
ScanCnt--;
if (ScanCnt == 0)
{
//扫描完成
Stop(); return;
}
} break;
}
}
private void FlushAD(Misc.DIRECTION direction)
{
int start_grid = 0;
int end_grid = mFlyAD.PosLen / mFlyAD.PosOfGrid;
int len = end_grid - start_grid + 1;
int[] dat;
mFlyAD.GetGrid(direction, start_grid, len, out dat);
if (EndEvent != null)
{
EndEvent(this, new MiniGridEventArgs()
{
grid_start = start_grid,
direction = direction,
posOfGrid = mFlyAD.PosOfGrid,
buf = dat
});
}
}
}
}