private void mainForm_Closing(Object sender, FormClosingEventArgs e)
{
List <TaskRecord> trList = TaskReordService.getInstance().getTaskRecordList();
DialogResult dr = System.Windows.Forms.DialogResult.No;
if (trList.Count > 0)
{
dr = MessageBox.Show("当前有任务没完成，确认退出?", "退出提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2);
}
else if (ElevatorFactory.getElevator().getOutCommand() != elevator.COMMAND_FROME2S.LIFT_OUT_COMMAND_MIN)
{
dr = MessageBox.Show("升降机上有任务，确认退出？", "退出提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2);
}
else
{
dr = MessageBox.Show("确认退出？", "退出提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button2);
}
if (dr == System.Windows.Forms.DialogResult.OK)
{
this.Dispose();
System.Environment.Exit(0);
}
else if (dr == System.Windows.Forms.DialogResult.Cancel)
{
e.Cancel = true;
}
}
private void cancelItemClick(object sender, EventArgs e)
{
MenuItem item = (MenuItem)sender;
TaskRecord tr = (TaskRecord)selectedButton.getBindValue();
if (tr != null && tr.taskRecordStat == TASKSTAT_T.TASK_READY_SEND)
{
int number = 0;
try {
if (selectedButton.st.taskText.Length == 2)
{
number = int.Parse(selectedButton.st.taskText.Substring(0, 1));
}
else if (selectedButton.st.taskText.Length == 3)
{
number = int.Parse(selectedButton.st.taskText.Substring(0, 2));
}
} catch (Exception ex) {
Console.WriteLine("parse task nunber err");
}
if (number % 2 == 1) //当前添加的是奇数任务，1，3，5，7，9，11号任务
{
bool exist = checkDoubleTaskRecord(selectedButton.st.taskID + 1);
if (exist)
{
DialogResult dr;
dr = MessageBox.Show(number + 1 + "号任务已经缓存，确定要取消该任务?", "任务添加提示", MessageBoxButtons.YesNo); //有偶数号任务被添加时，取消前面的任务，如果前面的货没有被移走，AGV会撞到前面的货
if (dr == DialogResult.No)
{
Console.WriteLine(" cancelItemClick cancel ");
return;
}
}
}
selectedButton.BackColor = Color.White;
TaskReordService.getInstance().removeTaskRecord(tr.singleTask, TASKSTAT_T.TASK_READY_SEND);
selectedButton.bindValue(null);
}
/*
* if (item.Name.Equals("cancelTaskItem"))
* {
*
* st = (SingleTask)this.SingleTaskDTG.CurrentCell.Value;
* }
* if (st != null)
* {
* st.taskStat = TASKSTAT_T.TASK_NOT_ASSIGN;
* this.SingleTaskDTG.CurrentCell.Style.BackColor = Color.White;
* AGVInitialize.getInitialize().getSchedule().removeTaskRecord(st, TASKSTAT_T.TASK_READY_SEND);
* }*/
}
private bool checkDoubleTaskRecord(int taskID) //检查是是否缓存了相对应的偶数任务,偶数不是指ID，是指任务号
{
bool exist = false;
List <TaskRecord> tsList = TaskReordService.getInstance().getReadySendTaskRecordList(taskID);
if (tsList.Count > 0)
{
exist = true;
}
return(exist);
}
private void handleRecordTask(string taskName, string cmd)
{
SingleTask st = SingleTaskDao.getDao().getSingleTaskByTaskName(taskName);
if (cmd.Equals("add"))
{
st.taskStat = TASKSTAT_T.TASK_SEND;
TaskReordService.getInstance().addTaskRecord(TASKSTAT_T.TASK_READY_SEND, st);
}
else if (cmd.Equals("remove"))
{
TaskReordService.getInstance().removeTaskRecord(st, TASKSTAT_T.TASK_READY_SEND);
}
}
private TaskRecord lookTaskRecordByTaskId(int taskID) //获取taskID对应的任务，如果任务列表中没有，则返回空
{
List <TaskRecord> trList = TaskReordService.getInstance().getTaskRecordList();
foreach (TaskRecord tr in trList)
{
if (tr.singleTask != null && tr.singleTask.taskID == taskID)
{
return(tr);
}
}
return(null);
}
private void addAllTaskRecordButton_Click(object sender, EventArgs e)
{
List <TaskRecord> listTaskRecords = TaskReordService.getInstance().getReadySendTaskRecordList();
if (listTaskRecords.Count > 0)
{
DialogResult dr;
dr = MessageBox.Show("有缓存任务，禁止一键添加", "提示", MessageBoxButtons.OK);
}
else
{
AGVUtil.addAllTaskRecord();
updateFrm();
}
}
public static void addAllTaskRecord()
{
List <SingleTask> singleTaskList = AGVCacheData.getSingleTaskList(); //获取所有的任务
foreach (SingleTask st in singleTaskList)
{
if (st.taskType == TASKTYPE_T.TASK_TYPE_UP_DILIVERY)
{
TaskRecord tr = new TaskRecord();
tr.singleTask = st;
tr.taskRecordName = st.taskName;
tr.taskRecordStat = TASKSTAT_T.TASK_READY_SEND;
TaskReordService.getInstance().addTaskRecord(tr);
}
}
}
/// <summary>
/// 将该任务的优先级提到最高 设置该任务的优先级，默认查询任务的时候将会参考该任务的有先级来查询
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void topItemClick(object sender, EventArgs e)
{
MenuItem item = (MenuItem)sender;
TaskRecord tr = (TaskRecord)selectedButton.getBindValue();
Console.WriteLine(" tr is nulll " + tr == null);
try {
if (checkTopFunc(tr))
{
selectedButton.BackColor = Color.Gray;
TaskReordService.getInstance().topTaskRecord(tr);
}
} catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
}
private void palletItemClick(object sender, EventArgs e)
{
MenuItem item = (MenuItem)sender;
Console.WriteLine("select button name = " + selectedButton.Name);
TaskRecord tr = (TaskRecord)selectedButton.getBindValue();
if (tr == null)
{
int number = 0;
try {
if (selectedButton.st.taskText.Length == 2)
{
number = int.Parse(selectedButton.st.taskText.Substring(0, 1));
}
else if (selectedButton.st.taskText.Length == 3)
{
number = int.Parse(selectedButton.st.taskText.Substring(0, 2));
}
} catch (Exception ex) {
Console.WriteLine("parse task nunber err");
}
if (number % 2 == 1) //当前添加的是奇数任务，1，3，5，7，9，11号任务
{
bool exist = checkDoubleTaskRecord(selectedButton.st.taskID + 1);
if (exist)
{
DialogResult dr;
dr = MessageBox.Show(number + 1 + "号任务已经缓存，该任务不能被添加", "任务添加提示", MessageBoxButtons.OK); //有偶数号任务被添加时，前面的奇数号任务不能被添加，否则AGV会撞到前面的货
if (dr == DialogResult.OK)
{
Console.WriteLine(" palletItemClick invalid ");
return;
}
}
}
selectedButton.BackColor = Color.LightGray;
tr = new TaskRecord();
tr.singleTask = selectedButton.st;
tr.taskRecordName = selectedButton.st.taskName;
tr.taskRecordStat = TASKSTAT_T.TASK_READY_SEND;
TaskReordService.getInstance().addTaskRecord(tr);
selectedButton.bindValue(tr);
}
}
/// <summary>
/// 可能有缓存任务，刚启动时，车子的状态需要设置
/// </summary>
private void setForkliftStateFirst()
{
foreach (ForkLiftWrapper fl in AGVCacheData.getForkLiftWrapperList())
{
List <TaskRecord> taskRecordList = TaskReordService.getInstance().getTaskRecordList();
foreach (TaskRecord tr in taskRecordList)
{
if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND || tr.taskRecordStat == TASKSTAT_T.TASK_SEND_SUCCESS)
{
if (tr.forkLiftWrapper != null && tr.forkLiftWrapper.getForkLift().forklift_number == fl.getForkLift().forklift_number)
{
fl.getForkLift().taskStep = TASK_STEP.TASK_EXCUTE;
}
}
}
}
}
private ENV_ERR_TYPE checkCacheTaskRecoreds()
{
ENV_ERR_TYPE err = ENV_ERR_TYPE.ENV_ERR_OK;
List <TaskRecord> taskRecordList = new List <TaskRecord>();
taskRecordList = TaskReordService.getInstance().getTaskRecordList();
if (checkCurrentPeriod(taskRecordList))
{
err = ENV_ERR_TYPE.ENV_CACHE_UPTASKRECORD_WARNING;
return(err);
}
if (taskRecordList.Count > 0)
{
err = ENV_ERR_TYPE.ENV_CACHE_TASKRECORD_WARNING;
}
return(err);
}
private void handleCheckRunning(ENV_ERR_TYPE err)
{
if (err == ENV_ERR_TYPE.ENV_LIFT_COM_ERR)
{
DialogResult dr;
dr = MessageBox.Show(env_err_type_text(err), "错误提示", MessageBoxButtons.OK);
if (dr == DialogResult.OK)
{
Console.WriteLine(" exit ");
Environment.Exit(0);
}
}
else if (err == ENV_ERR_TYPE.ENV_CACHE_TASKRECORD_WARNING)
{
DialogResult dr;
dr = MessageBox.Show(env_err_type_text(err), "检测到缓存任务", MessageBoxButtons.YesNo);
if (dr == DialogResult.Yes)
{
Console.WriteLine(" do nothing ");
}
else if (dr == DialogResult.No)
{
TaskReordService.getInstance().deleteAllTaskRecord();
}
}
else if (err == ENV_ERR_TYPE.ENV_CACHE_UPTASKRECORD_WARNING)
{
DialogResult dr;
dr = MessageBox.Show(env_err_type_text(err), "缓存任务", MessageBoxButtons.YesNo);
if (dr == DialogResult.Yes)
{
ScheduleFactory.getSchedule().setDownDeliverPeriod(true); //设置当前处于上货阶段
}
else if (dr == DialogResult.No)
{
TaskReordService.getInstance().deleteAllTaskRecord();
}
}
}
/// <summary>
/// 检测是否缓存了该货物前面的任务，如果有，需要取消前面一个任务再置顶，否则会出现前面的货物没叉玩，直接叉了后面的货物
/// </summary>
/// <param name="taskRecord"></param>
/// <returns></returns>
private bool checkTopFunc(TaskRecord taskRecord)
{
bool ret = true;
Console.WriteLine("taskRecord.singleTask.taskID = " + taskRecord.singleTask.taskID);
if (taskRecord.singleTask.taskID % 2 == 1) //表示里面一排货物, 注意是taskID
{
List <TaskRecord> trList = TaskReordService.getInstance().getTaskRecordList(taskRecord.singleTask.taskID - 1);
foreach (TaskRecord tr in trList)
{
if (tr.taskRecordStat == TASKSTAT_T.TASK_READY_SEND)
{
MessageBox.Show("需要先取消前面货物的任务", "置顶提示", MessageBoxButtons.OK);
ret = false;
}
}
}
return(ret);
}
/// <summary>
/// 检查任务状态
/// </summary>
private bool checkTaskSendStat(ForkLiftWrapper fl, string taskName)
{
bool stat = true;
if (fl.getForkLift().finishStatus == 1)
{
foreach (TaskRecord tr in TaskReordService.getInstance().getTaskRecordList())
{
if (tr.forkLiftWrapper != null && tr.forkLiftWrapper.getForkLift().id == fl.getForkLift().id)
{
if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND)
{
if (fl.getForkLift().waitTimes > 15)
{
Console.WriteLine("send task: " + taskName + "to " + fl.getForkLift().forklift_number + "fail");
fl.getForkLift().waitTimes = 0;
tr.forkLiftWrapper = null;
fl.getForkLift().taskStep = TASK_STEP.TASK_IDLE;
fl.getForkLift().currentTask = "";
DBDao.getDao().updateForkLift(fl);
if (tr.singleTask.taskType == TASKTYPE_T.TASK_TYPE_UP_PICK)
{
DBDao.getDao().RemoveTaskRecord(tr);
AGVLog.WriteWarn("forklift number: " + fl.getForkLift().forklift_number + " taskName: " + taskName + " 发送失败 移除任务", new StackFrame(true));
}
else
{
tr.taskRecordStat = TASKSTAT_T.TASK_READY_SEND;
tr.singleTask.taskStat = TASKSTAT_T.TASK_READY_SEND;
DBDao.getDao().UpdateTaskRecord(tr);
AGVLog.WriteWarn("forklift number: " + fl.getForkLift().forklift_number + " taskName: " + taskName + " 发送失败 更新任务状态，等待重新发送", new StackFrame(true));
}
FormController.getFormController().getMainFrm().updateFrm();
}
else
{
fl.getForkLift().waitTimes++;
Console.WriteLine("fl: " + fl.getForkLift().forklift_number + "taskName: " + taskName + "waittimes: " + fl.getForkLift().waitTimes);
AGVLog.WriteWarn("forklift number: " + fl.getForkLift().forklift_number + " taskName: " + taskName + " waittimes: " + fl.getForkLift().waitTimes, new StackFrame(true));
}
break;
}
else if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND_SUCCESS)
{
Console.WriteLine("task: " + taskName + "in " + fl.getForkLift().forklift_number + "finished");
AGVLog.WriteInfo("taskName: " + taskName + "in " + fl.getForkLift().forklift_number + " finished", new StackFrame(true));
DBDao.getDao().RemoveTaskRecord(tr);
DBDao.getDao().InsertTaskRecordBak(tr);
tr.singleTask.taskStat = TASKSTAT_T.TASK_END;
tr.taskRecordStat = TASKSTAT_T.TASK_END;
FormController.getFormController().getMainFrm().updateFrm();
fl.getForkLift().taskStep = TASK_STEP.TASK_IDLE;
fl.getForkLift().currentTask = "";
DBDao.getDao().updateForkLift(fl);
break;
}
else if (tr.taskRecordStat == TASKSTAT_T.TASK_END)
{
//break; 继续任务状态没及时删除,继续循环
}
break; //每次只匹配一条记录，可能存在两条记录，对应singleTask一样，一条正在运行，一条待发送，适应一键添加功能
}
}
}
else if (fl.getForkLift().finishStatus == 0)
{
//bool storeTask = true; //是否需要缓存该任务
foreach (TaskRecord tr in TaskReordService.getInstance().getTaskRecordList())
{
//Console.WriteLine(" tr stat = " + tr.taskRecordStat + " taskName = " + tr.taskRecordName);
if (tr.forkLiftWrapper != null && tr.forkLiftWrapper.getForkLift().id == fl.getForkLift().id) //任务列表中匹配到非待发送的该任务则不缓存
{
if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND)
{
tr.singleTask.taskStat = TASKSTAT_T.TASK_SEND_SUCCESS;
tr.taskRecordStat = TASKSTAT_T.TASK_SEND_SUCCESS;
DBDao.getDao().UpdateTaskRecord(tr);
stat = true;
}
else if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND_SUCCESS && tr.forkLiftWrapper.getForkLift().id == fl.getForkLift().id)
{
}
fl.getForkLift().waitTimes = 0; //发送任务，等待确认是否发送成功
fl.getForkLift().taskStep = TASK_STEP.TASK_EXCUTE;
fl.getForkLift().currentTask = tr.singleTask.taskText;
break; //每次只匹配一条记录，可能存在两条记录，对应singleTask一样，一条正在运行，一条待发送，适应一键添加功能
}
}
}
else
{
Console.WriteLine("fork status err");
AGVLog.WriteError("fork lift staus: " + fl.getForkLift().finishStatus + "err", new StackFrame(true));
}
return(stat);
}
/// <summary>
/// 检查任务状态
/// </summary>
/// <param name="fl">车子实例</param>
/// <param name="taskName"></param>
/// <returns></returns>
private bool checkTaskSendStat(ForkLiftWrapper fl, string taskName)
{
bool stat = true;
//Console.WriteLine(" fl id " + fl.getForkLift().id + " finishStatus = " + fl.finishStatus);
if (fl.getForkLift().finishStatus == 1) //车子状态空闲有两种可能1：车子任务执行完成 2：任务在执行中 报文没有及时反馈
{
foreach (TaskRecord tr in TaskReordService.getInstance().getTaskRecordList())
{
//if (tr.forkLift != null && tr.taskRecordName.Equals(taskName))
if (tr.forkLiftWrapper != null && tr.forkLiftWrapper.getForkLift().id == fl.getForkLift().id) //可能存在任务没发送成功，反馈的taskName与现在taskrecord的名称不一样
{
if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND)
{
if (fl.getForkLift().waitTimes > 15) //等待次数超过15次，后面重新发送该任务
{
Console.WriteLine("send task: " + taskName + "to " + fl.getForkLift().forklift_number + "fail");
fl.getForkLift().waitTimes = 0;
tr.forkLiftWrapper = null;
fl.getForkLift().taskStep = TASK_STEP.TASK_IDLE; //车子状态改为空闲
fl.getForkLift().currentTask = "";
DBDao.getDao().updateForkLift(fl); //赋值空字符串
if (tr.singleTask.taskType == TASKTYPE_T.TASK_TYPE_UP_PICK)
{
DBDao.getDao().RemoveTaskRecord(tr);
AGVLog.WriteWarn("forklift number: " + fl.getForkLift().forklift_number + " taskName: " + taskName + " 发送失败 移除任务", new StackFrame(true));
}
else
{
tr.taskRecordStat = TASKSTAT_T.TASK_READY_SEND; //改变任务的状态，后面重新发送
tr.singleTask.taskStat = TASKSTAT_T.TASK_READY_SEND;
DBDao.getDao().UpdateTaskRecord(tr);
AGVLog.WriteWarn("forklift number: " + fl.getForkLift().forklift_number + " taskName: " + taskName + " 发送失败 更新任务状态，等待重新发送", new StackFrame(true));
}
FormController.getFormController().getMainFrm().updateFrm(); //设置更新界面
}
else
{
fl.getForkLift().waitTimes++;
Console.WriteLine("fl: " + fl.getForkLift().forklift_number + "taskName: " + taskName + "waittimes: " + fl.getForkLift().waitTimes);
AGVLog.WriteWarn("forklift number: " + fl.getForkLift().forklift_number + " taskName: " + taskName + " waittimes: " + fl.getForkLift().waitTimes, new StackFrame(true));
}
break;
}
else if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND_SUCCESS) //确保没有重复进入，否则会插入多条备份记录
{
Console.WriteLine("task: " + taskName + "in " + fl.getForkLift().forklift_number + "finished");
AGVLog.WriteInfo("taskName: " + taskName + "in " + fl.getForkLift().forklift_number + " finished", new StackFrame(true));
DBDao.getDao().RemoveTaskRecord(tr); //移除record是3的记录
DBDao.getDao().InsertTaskRecordBak(tr);
tr.singleTask.taskStat = TASKSTAT_T.TASK_END;
tr.taskRecordStat = TASKSTAT_T.TASK_END;
FormController.getFormController().getMainFrm().updateFrm(); //设置更新界面 //设置更新界面
fl.getForkLift().taskStep = TASK_STEP.TASK_IDLE;
fl.getForkLift().currentTask = "";
DBDao.getDao().updateForkLift(fl);
break;
}
else if (tr.taskRecordStat == TASKSTAT_T.TASK_END)
{
//break; 继续任务状态没及时删除,继续循环
}
break; //每次只匹配一条记录，可能存在两条记录，对应singleTask一样，一条正在运行，一条待发送，适应一键添加功能
}
}
}
else if (fl.getForkLift().finishStatus == 0)
{
//bool storeTask = true; //是否需要缓存该任务
foreach (TaskRecord tr in TaskReordService.getInstance().getTaskRecordList())
{
//Console.WriteLine(" tr stat = " + tr.taskRecordStat + " taskName = " + tr.taskRecordName);
if (tr.forkLiftWrapper != null && tr.forkLiftWrapper.getForkLift().id == fl.getForkLift().id) //任务列表中匹配到非待发送的该任务则不缓存
{
if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND)
{
tr.singleTask.taskStat = TASKSTAT_T.TASK_SEND_SUCCESS;
tr.taskRecordStat = TASKSTAT_T.TASK_SEND_SUCCESS;
DBDao.getDao().UpdateTaskRecord(tr);
stat = true;
}
else if (tr.taskRecordStat == TASKSTAT_T.TASK_SEND_SUCCESS && tr.forkLiftWrapper.getForkLift().id == fl.getForkLift().id)
{
}
fl.getForkLift().waitTimes = 0; //发送任务，等待确认是否发送成功
fl.getForkLift().taskStep = TASK_STEP.TASK_EXCUTE;
fl.getForkLift().currentTask = tr.singleTask.taskText;
break; //每次只匹配一条记录，可能存在两条记录，对应singleTask一样，一条正在运行，一条待发送，适应一键添加功能
}
}
/*
* if (storeTask) //系统启动后，车子可能正在执行任务起来，将正在执行的任务缓存
* {
* TaskRecord tr = new TaskRecord();
* tr.taskRecordName = taskName;
* tr.forkLift = fl;
* tr.taskRecordStat = TASKSTAT_T.TASK_SEND_SUCCESS; //状态已经发送成功
* tr.setSingleTaskByTaskName(AGVUtil.parseTaskRecordName(taskName));
* fl.getForkLift().taskStep = TASK_STEP.TASK_EXCUTE;
* addTs = tr;
* //AGVInitialize.getInitialize().getMainFrm().updateCurrentTask(st.taskName); //更新界面上的当前任务
* Console.WriteLine("store task: " + tr.taskRecordName + "taskNumber:" + taskRecordList.Count);
* AGVLog.WriteInfo("store task: " + tr.taskRecordName + "at boot task count: " + taskRecordList.Count, new StackFrame(true));
* }
*/
}
else
{
Console.WriteLine("fork status err");
AGVLog.WriteError("fork lift staus: " + fl.getForkLift().finishStatus + "err", new StackFrame(true));
}
return(stat);
}
public void sheduleTask() {
ForkLiftWrapper tmpForkLiftWrapper = null;
SingleTask tmpSingleTask = null;
int upRecordStep = 0; //没有上货， 该值大于0的时候，表示上货还没有结束，可能存在升降机正在运送，车子当前没有任务
int downRecordStep = 0; //没有下货，该值大于0的时候， 表示下货没有结束
int result = -1;
///***开始处理任务的循环语句***///
while (ScheduleFactory.getSchedule().getScheduleFlag()) {
Thread.Sleep(2000);
if (AGVSystem.getSystem().getSystemPause()) { //系统暂停后，调度程序不执行
Console.WriteLine("system pause");
continue;
}
//Console.WriteLine(" shedule Task");
lock (LockController.getLockController().getLockTask()) {
taskRecordList = TaskReordService.getInstance().getTaskRecordList();
upTaskRecord = checkUpTaskRecord();
}
//if (upTaskRecord != null)
// Console.WriteLine(" upTaskRecord name = " + upTaskRecord.taskRecordName);
if (ScheduleFactory.getSchedule().getDownDeliverPeriod()) //当前处于上货阶段，有的话控制升降机上升
{
//读取升降机上料信号
if (ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_UP) //检测到楼下有货，发送指令到升降机运货到楼上
{
ElevatorFactory.getElevator().setDataCommand(COMMAND_FROMS2E.LIFT_IN_COMMAND_UP);
while (ElevatorFactory.getElevator().getOutCommand() != COMMAND_FROME2S.LIFT_OUT_COMMAND_DOWN) //等待升降机送货到楼上
{
Console.WriteLine("wait lifter up goods");
Thread.Sleep(100);
}
if (upRecordStep > 0) //升降机将货运到楼上,保证upRecordStep不小于0
{
upRecordStep--;
AGVLog.WriteError("上货期间 升降机将货运送到楼上: step = " + upRecordStep, new StackFrame(true));
}
}
if (ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_DOWN
|| ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_UP_DOWN) //上货期间 楼上楼下都有货， 楼上的车子需要继续运行
{
lock (LockController.getLockController().getLockForkLift()) {
//运动到楼上后，发送指令到楼上AGV，把货取走
tmpForkLiftWrapper = getSheduleForkLift();
if (tmpForkLiftWrapper != null) {
tmpSingleTask = getUpPickSingleTaskOnTurn();
TaskRecord tr_tmp = new TaskRecord();
tr_tmp.singleTask = tmpSingleTask;
tr_tmp.taskRecordName = tmpSingleTask.taskName;
TaskReordService.getInstance().addTaskRecord(tr_tmp);
tmpForkLiftWrapper.sendTask(tr_tmp); //发送任务
upPicSingleTaskkUsed++; //用于下次切换卸货点
} else {
Console.WriteLine(" 楼上没有可用的车去卸货");
AGVLog.WriteError(" 楼上没有可用的车去卸货", new StackFrame(true));
}
}
if (tmpForkLiftWrapper != null) {
while (ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_DOWN
|| ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_UP_DOWN) //等待楼上货物被取走,如果车的状态回到idle,说明任务发送失败
{
if (tmpForkLiftWrapper.getForkLift().taskStep == TASK_STEP.TASK_IDLE) {
break;
}
Console.WriteLine("wait lifter goods to be pick");
Thread.Sleep(500);
}
if (upRecordStep > 0) //升降机将货运到楼上,保证upRecordStep不小于0
{
upRecordStep--;
AGVLog.WriteError("上货期间 楼上货物被取走: step = " + upRecordStep, new StackFrame(true));
}
}
}
if (checkDownDeliverPeriodOver(upRecordStep)) //检测上料任务有没有结束 条件1：没有上料任务缓存 条件2：所有车子空闲 条件3：升降机上没有货物
{
ScheduleFactory.getSchedule().setDownDeliverPeriod ( false);
}
downRecordStep = 0; //下料信号置0
Console.WriteLine("上料阶段");
}
if (upTaskRecord != null) {
if (!ScheduleFactory.getSchedule().getDownDeliverPeriod() && !checkUpDeliverPeriodOver(downRecordStep)) //检查下货任务有没有结束，升降机从楼上到楼下流程走完，没有正在执行的下货任务
{
Console.WriteLine("当前下货任务没有执行完成，执行完后再开始执行上货任务");
} else if (upTaskRecord.taskRecordStat == TASKSTAT_T.TASK_READY_SEND) {
tmpForkLiftWrapper = ForkLiftWrappersService.getInstance().getForkLiftByNunber(3); //获取楼下三号车
if (tmpForkLiftWrapper.getForkLift().taskStep != TASK_STEP.TASK_IDLE) {
Console.WriteLine("上料任务正在执行，等待上料任务执行完成");
continue;
}
if (ElevatorFactory.getElevator().getOutCommand() != COMMAND_FROME2S.LIFT_OUT_COMMAND_MIN) //只要升降机上有货或有异常都不发送上货任务，否则容易造成楼上楼下都要货
{
Console.WriteLine(" 升降机楼下有货，不发送上货任务");
} else {
lock (LockController.getLockController().getLockForkLift()) //锁住车的状态
{
result = tmpForkLiftWrapper.sendTask(upTaskRecord); //发送任务
ScheduleFactory.getSchedule().setDownDeliverPeriod(true);//上货任务发送后，才进入上料阶段
if (result == 0) //发送成功 才正式进入上货阶段
{
if (upRecordStep <= 2) //避免上货 step被加得太多，不能进入下货阶段
{
upRecordStep += 2;
AGVLog.WriteError("上货期间 发送任务: step = " + upRecordStep, new StackFrame(true));
}
}
}
}
}
}
//检测升降机2楼有货物，发送指令将升降机送货到楼下
//检测升降机1楼有货物，调度1楼AGV送货
//读取升降机上料信号
if (!ScheduleFactory.getSchedule().getDownDeliverPeriod()) {
Console.WriteLine(" 下料阶段");
upRecordStep = 0; //上料信号置0
if (ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_DOWN) //检测到楼上有货，发送指令到升降机运货到楼下
{
int times_tmp = 0;
ElevatorFactory.getElevator().setDataCommand(COMMAND_FROMS2E.LIFT_IN_COMMAND_DOWN);
while (ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_DOWN && times_tmp < 60) //等待升降机送货到楼下
{
Console.WriteLine("wait lifter down goods"); //光电感应大概10S可以结束
times_tmp++;
Thread.Sleep(1000);
}
if (times_tmp < 60) {
if (downRecordStep > 0) //升降机将货运到楼上,保证upRecordStep不小于0
{
downRecordStep--;
AGVLog.WriteError("下货期间 楼上货物送到楼下: step = " + downRecordStep, new StackFrame(true));
}
}
times_tmp = 0;
}
if (ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_UP ||
ElevatorFactory.getElevator().getOutCommand() == COMMAND_FROME2S.LIFT_OUT_COMMAND_UP_DOWN) //检测到楼下有货，通知AGV来取货
{
TaskRecord tr_tmp = new TaskRecord();
tmpForkLiftWrapper = ForkLiftWrappersService.getInstance().getForkLiftByNunber(3);
tmpSingleTask = getDownPickSingleTaskOnTurn();
tr_tmp.singleTask = tmpSingleTask;
tr_tmp.taskRecordName = tmpSingleTask.taskName;
if (tmpForkLiftWrapper != null && tmpForkLiftWrapper.getForkLift().taskStep == TASK_STEP.TASK_IDLE) {
TaskReordService.getInstance().addTaskRecord(tr_tmp); //发货后，才确认添加该记录
result = tmpForkLiftWrapper.sendTask(tr_tmp);
if (result == 0) //任务发送成功
{
downPicSingleTaskkUsed++; //用于下次切换卸货点
if (downRecordStep > 0) //升降机将货运到楼上,保证upRecordStep不小于0
{
downRecordStep--;
AGVLog.WriteError("下货期间 楼下货物被取走: step = " + downRecordStep, new StackFrame(true));
}
} else {
TaskReordService.getInstance().removeTaskRecord(tr_tmp.singleTask, tr_tmp.taskRecordStat); //如果任务没发送成功，删除该条记录
}
}
}
lock (LockController.getLockController().getLockTask()) {
foreach (TaskRecord tr in taskRecordList) {
lock (LockController.getLockController().getLockForkLift()) {
if (tr.taskRecordStat == TASKSTAT_T.TASK_READY_SEND) {
tmpForkLiftWrapper = null;
if (tr.singleTask.taskType == TASKTYPE_T.TASK_TYPE_DOWN_PICK)
tmpForkLiftWrapper = ForkLiftWrappersService.getInstance().getForkLiftByNunber(3);
else if (tr.singleTask.taskType == TASKTYPE_T.TASK_TYPE_UP_DILIVERY)
tmpForkLiftWrapper = getSheduleForkLift(); //有任务执行的时候，才考虑检查车子状态
//if (fl.getForkLift().taskStep == TASK_STEP.TASK_IDLE && fl.finishStatus == 1) //检查车子的状态，向空闲的车子发送任务,如果发送失败，后面会检测发送状态，
//并将该任务状态改成待发重新发送
if (tmpForkLiftWrapper != null && tmpForkLiftWrapper.getForkLift().taskStep == TASK_STEP.TASK_IDLE) {
result = tmpForkLiftWrapper.sendTask(tr); //发送任务
if (result == -1) //任务没有发送成功会中断本次循环，防止发送任务到后面的车
{
break;
}
if (tr.singleTask.taskType == TASKTYPE_T.TASK_TYPE_UP_DILIVERY && downRecordStep < 4) //发送的是楼上送货，并且送货发送次数小于2次
{
downRecordStep += 2;
AGVLog.WriteError("下货期间 发送任务: step = " + downRecordStep, new StackFrame(true));
}
}
}
}
}
}
}
}
}
