コード例 #1
0
    private void ThreadOpenStoveLid()
    {
        while (true)
        {
            Thread.Sleep(100);

            if (!GenericOp.AutoMode) continue;
            // 只有在龙门不再炉盖附近时,才允许打开,否则很危险。
            if (ABTask.loadPoints == null) continue;

            // 安全规则判断
            if ((GenericOp.xPos < ABTask.loadPoints[openStoveLidPos].X + 1200) &&
                    (GenericOp.xPos > ABTask.loadPoints[openStoveLidPos].X - 1200))
            {
                SerialManual.StopStoveLidCmd(openStoveLidPos);// 如果在龙门附近打开盖子,就停止所有盖子的动作。
            }
            if ((GenericOp.xPos < ABTask.loadPoints[closeStoveLidPos].X + 1200) &&
                    (GenericOp.xPos > ABTask.loadPoints[closeStoveLidPos].X - 1200))
            {
                SerialManual.StopStoveLidCmd(closeStoveLidPos);// 如果在龙门附近打开盖子,就停止所有盖子的动作。
            }

            // --------------------------------------------------------------
            // 打开、关闭、停止炉盖动作
            //
            // 需要打开炉盖的炉子有    _ _ _ 3、4、5、6 _ _ _ _、11、12
            int tmpPos;
            for (int i = 0; i < 7; i++)
            {
                if (stoveLidAction[i] == STOVE_LID_ACTION.CLOSE)
                {
                    tmpPos = GetPos_fromStoveLidIndex(i);
                    if ((GenericOp.xPos < ABTask.loadPoints[tmpPos].X + 1200) &&
                    (GenericOp.xPos > ABTask.loadPoints[tmpPos].X - 1200))
                    {
                        continue;// 夹爪在炉子上方,就忽略关闭命令
                    }
                    SerialManual.CloseStoveLid(i);// 关闭炉盖
                }
                else if (stoveLidAction[i] == STOVE_LID_ACTION.OPEN)
                {
                    tmpPos = GetPos_fromStoveLidIndex(i);
                    if ((GenericOp.xPos < ABTask.loadPoints[tmpPos].X + 1200) &&
                    (GenericOp.xPos > ABTask.loadPoints[tmpPos].X - 1200))
                    {
                        continue;// 夹爪在炉子上方,就忽略打开命令
                    }
                    SerialManual.OpenStoveLid(i);// 打开炉盖
                }
                if (stoveLidAction[i] == STOVE_LID_ACTION.NO_ACTION)
                {
                    SerialManual.StopStoveLidCmd(i);// 停止炉盖动作
                }
            }
        }
    }
コード例 #2
0
    private void ThreadAB()
    {
        while (true)
        {
            Thread.Sleep(100);

            // 执行任务列表中的任务,执行完成的,就从任务列表中删除。
            if (currTask != null)
            {
                // ---------------------------------------------------
                // 根据任务状态执行任务
                //
                if (currTask.taskStatus == ABTask.STATUS.IDLE)
                {                                             //
                    if (currTask.AB_TASK_A == hyWorkFlow.POS_LOAD)
                    {                                         // 如果是新的任务(新的夹具),那么就添加到夹具列表
                        shareCarrierRes.mutex.WaitOne();      //申请(互斥,互锁)
                        carrierList.Add(currTask.carrier);
                        shareCarrierRes.mutex.ReleaseMutex(); // 释放
                    }
                    //
                    currTask.taskStatus = ABTask.STATUS.PREA;// 更新任务状态
                    currCarrier         = currTask.carrier;
                    // 更新任务信息,记录到xml中
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.PREA, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.PREA)
                {
                    if (((GenericOp.xPos < 4275)) || ((GenericOp.xPos > 11955) && (GenericOp.xPos < 16105)))
                    {
                        for (int a = 0; a < 6; a++)    //检查炉盖是否都已经关闭 关闭才允许运行
                        {
                            SerialManual.STOVE_LID_STATE state;
                            state = SerialManual.stoveLidState[a];
                            while (state != SerialManual.STOVE_LID_STATE.CLOSED)
                            {
                                Thread.Sleep(500);
                                state = SerialManual.stoveLidState[a];
                                SerialManual.CloseStoveLid(a);
                            }
                        }
                    }

                    // 炉盖打开任务
                    int i = GetStoveLidIndex(currTask.AB_TASK_A);
                    if (i >= 0)
                    {
                        stoveLidAction[i] = STOVE_LID_ACTION.OPEN;// 要打开 A pos 的炉盖
                    }

                    int b = currTask.AB_TASK_A;
                    switch (b)//关闭前一个水槽搅拌
                    {
                    case 0:
                        SerialManual.CloseStoveLid(8);
                        break;

                    case 1:
                        SerialManual.CloseStoveLid(9);
                        break;

                    case 2:
                        SerialManual.CloseStoveLid(10);
                        break;

                    case 3:
                        SerialManual.CloseStoveLid(11);
                        break;

                    case 8:
                        SerialManual.CloseStoveLid(12);
                        break;

                    case 9:
                        SerialManual.CloseStoveLid(13);
                        break;

                    case 10:
                        SerialManual.CloseStoveLid(14);
                        break;

                    default:
                        break;
                    }
                    //
                    PRE_A_DOING();
                    currTask.taskStatus = ABTask.STATUS.CLAMPA;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.CLAMPA, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.CLAMPA)
                {
                    CLAMPA_DOING();
                    currTask.taskStatus = ABTask.STATUS.PREB;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.PREB, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.PREB)
                {
                    // 炉盖关闭任务
                    int i = GetStoveLidIndex(currTask.AB_TASK_A);
                    if (i >= 0)
                    {
                        stoveLidAction[i] = STOVE_LID_ACTION.CLOSE;// 要关闭 A pos 的炉盖
                    }

                    // 炉盖打开任务
                    i = GetStoveLidIndex(currTask.AB_TASK_B);
                    if (i >= 0)
                    {
                        stoveLidAction[i] = STOVE_LID_ACTION.OPEN;// 要打开 B pos 的炉盖
                    }
                    int b = currTask.AB_TASK_B;
                    switch (b)//打开水槽搅拌等
                    {
                    case 0:
                        SerialManual.OpenStoveLid(8);
                        break;

                    case 1:
                        SerialManual.OpenStoveLid(9);
                        break;

                    case 2:
                        SerialManual.OpenStoveLid(10);
                        break;

                    case 3:
                        SerialManual.OpenStoveLid(11);
                        break;

                    case 8:
                        SerialManual.OpenStoveLid(12);
                        break;

                    case 9:
                        SerialManual.OpenStoveLid(13);
                        break;

                    case 10:
                        SerialManual.OpenStoveLid(14);
                        break;

                    default:
                        break;
                    }
                    PRE_B_DOING();

                    currTask.taskStatus = ABTask.STATUS.RELAXB;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.RELAXB, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.RELAXB)
                {
                    RELAXB_DOING();
                    currTask.taskStatus = ABTask.STATUS.AFTERB;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.AFTERB, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.AFTERB)
                {
                    // 炉盖关闭任务
                    int i = GetStoveLidIndex(currTask.AB_TASK_B);
                    if (i >= 0)
                    {
                        stoveLidAction[i] = STOVE_LID_ACTION.CLOSE;// 要关闭 B pos 的炉盖
                    }

                    AFTER_B_DOING();
                    if (currTask.AB_TASK_B == hyWorkFlow.POS_UNLOAD)
                    {                                         // 如果到达了卸载位,就移除夹具
                        SerialWireless.gtryCmd = SerialWireless.GTYRY_CMD.UN_LOAD;
                        shareCarrierRes.mutex.WaitOne();      //申请(互斥,互锁)
                        carrierList.Remove(currTask.carrier);
                        shareCarrierRes.mutex.ReleaseMutex(); //  释放
                    }

                    currTask.taskStatus = ABTask.STATUS.STOP;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.STOP, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
            }
        }
    }
コード例 #3
0
    private void ThreadAB()
    {
        while (true)
        {
            Thread.Sleep(100);

            // 执行任务列表中的任务,执行完成的,就从任务列表中删除。
            if (currTask != null)
            {
                // ---------------------------------------------------
                // 根据任务状态执行任务
                //
                if (currTask.taskStatus == ABTask.STATUS.IDLE)
                {//
                    if (currTask.AB_TASK_A == hyWorkFlow.POS_LOAD)
                    {// 如果是新的任务(新的夹具),那么就添加到夹具列表
                        shareCarrierRes.mutex.WaitOne();//申请(互斥,互锁)
                        carrierList.Add(currTask.carrier);
                        shareCarrierRes.mutex.ReleaseMutex();// 释放
                    }
                    //
                    currTask.taskStatus = ABTask.STATUS.PREA;// 更新任务状态
                    currCarrier = currTask.carrier;
                    // 更新任务信息,记录到xml中
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.PREA, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.PREA)
                {
                   /* if (((GenericOp.xPos < 4360)) || ((GenericOp.xPos > 13965) && (GenericOp.xPos < 21478)))
                    {
                        for (int a = 0; a < 7; a++)    //检查炉盖是否都已经关闭 关闭才允许运行
                        {
                            SerialManual.STOVE_LID_STATE state;
                            state = SerialManual.stoveLidState[a];
                            if (state != SerialManual.STOVE_LID_STATE.CLOSED)
                            {
                                SerialManual.CloseStoveLid(a);
                            }
                            while (state != SerialManual.STOVE_LID_STATE.CLOSED)
                            {
                                Thread.Sleep(500);
                                state = SerialManual.stoveLidState[a];
                                
                            }
                            
                        }
                    }
                    */
                    // 炉盖打开任务
                    int i = GetStoveLidIndex(currTask.AB_TASK_A);
                    if (i >= 0)
                    {
                        stoveLidAction[i] = STOVE_LID_ACTION.OPEN;// 要打开 A pos 的炉盖
                    }
                    //SerialManual.CloseStoveLid(8);//关闭后门
                    /*if (currTask.AB_TASK_A == hyWorkFlow.POS_LOAD)//打开前门
                    {
                        SerialManual.STOVE_LID_STATE state;
                        SerialManual.CloseStoveLid(7);//打开前门
                        state = SerialManual.stoveLidState[8];// 查看前门的状态
                        while (state != SerialManual.STOVE_LID_STATE.ERROR)
                        {// 等待炉盖打开到位信号。
                            Thread.Sleep(100);// 等待前门打开
                            state = SerialManual.stoveLidState[8];// 查看前门状态

                            // 超时处理
                            // TODO: 如果60秒都没有打开的话,需要给出提示信息。告诉用户炉盖故障:接近开关故障。
                            timeout_openStoveLid++;
                            if (timeout_openStoveLid > 600)
                            {
                                GenericOp.errCode |= 0x01;
                            }
                        }
                    }*/
                    if (GenericOp.GREASEnum > 7)//注油 润滑
                    {
                        SerialWireless.gtryCmd = SerialWireless.GTYRY_CMD.GREASE;
                    }
                    //
                    PRE_A_DOING();

                    currTask.taskStatus = ABTask.STATUS.CLAMPA;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.CLAMPA, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.CLAMPA)
                {
                    CLAMPA_DOING();
                    currTask.taskStatus = ABTask.STATUS.PREB;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.PREB, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.PREB)
                {
                    // 炉盖关闭任务
                    int i = GetStoveLidIndex(currTask.AB_TASK_A);
                    if (i >= 0)
                    {
                        stoveLidAction[i] = STOVE_LID_ACTION.CLOSE;

                        // 要关闭 A pos 的炉盖

                    }
                    /*if (currTask.AB_TASK_B == hyWorkFlow.POS_UNLOAD) //打开后门
                    {
                        SerialManual.OpenStoveLid(8);
                        SerialManual.STOVE_LID_STATE state;
                        state = SerialManual.stoveLidState[7];// 查看后门的状态
                        while (state != SerialManual.STOVE_LID_STATE.ERROR)
                        {// 等待炉盖打开到位信号。
                            Thread.Sleep(100);// 等待前门打开
                            state = SerialManual.stoveLidState[7];// 查看hou门状态

                            // 超时处理
                            // TODO: 如果60秒都没有打开的话,需要给出提示信息。告诉用户炉盖故障:接近开关故障。
                            timeout_openStoveLid++;
                            if (timeout_openStoveLid > 600)
                            {
                                GenericOp.errCode |= 0x01;
                            }
                        }
                    }
                    */
                    // 炉盖打开任务
                    i = GetStoveLidIndex(currTask.AB_TASK_B);
                    if (i >= 0)
                    {
                        stoveLidAction[i] = STOVE_LID_ACTION.OPEN;// 要打开 B pos 的炉盖
                    }

                    PRE_B_DOING();
                    currTask.taskStatus = ABTask.STATUS.RELAXB;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.RELAXB, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.RELAXB)
                {
                    if (currTask.AB_TASK_A == hyWorkFlow.POS_LOAD)//关闭前门
                    {
                        SerialManual.OpenStoveLid(7);
                    }
                    RELAXB_DOING();
                    currTask.taskStatus = ABTask.STATUS.AFTERB;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.AFTERB, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
                else if (currTask.taskStatus == ABTask.STATUS.AFTERB)
                {
                    // 炉盖关闭任务
                    int i = GetStoveLidIndex(currTask.AB_TASK_B);
                    if (i >= 0)
                    {
                        switch (i)
                        {
                            case 3:
                                stoveLidAction[i] = STOVE_LID_ACTION.OPEN;
                                break;
                            default:
                                stoveLidAction[i] = STOVE_LID_ACTION.CLOSE;
                                break;
                        }
                        // 要关闭 B pos 的炉盖 4号炉不关闭
                    }

                    AFTER_B_DOING();
                    //if (currTask.AB_TASK_B == hyWorkFlow.POS_UNLOAD)//到达卸载位卸货
                    if(currTask.AB_TASK_B==9)//到达9号水槽及卸货
                    {// 如果到达了卸载位,就移除夹具
                        shareCarrierRes.mutex.WaitOne();//申请(互斥,互锁)
                        carrierList.Remove(currTask.carrier);
                        shareCarrierRes.mutex.ReleaseMutex();//  释放
                    }

                    currTask.taskStatus = ABTask.STATUS.STOP;// 更新任务状态
                    UpdateXmlNodeTaskInfo(ABTask.STATUS.STOP, currTask.AB_TASK_A, currTask.AB_TASK_B, currTask.carrier.id);
                }
            }
        }
    }