Ejemplo n.º 1
0
        public IProductionStage Work(object args, out object result)
        {
            var context = (HuiJinYunProductionContext)args;

#if DEBUG
            Logger.LogInfo($"PeptizationStage Start");
#endif

            /*
             * Status = eProductionStageState.Busy;
             * _switch.Reset(); Thread.Sleep(1000);
             * _switch.Reset(false);
             * new NotifyWatcher(_switch).WaitOne((s, a) => { return Bit.Tst(_switch.Status, eSwitchState.SwitchEnd); }, 1000);
             * Thread.Sleep(5000);
             * _switch.Reset(); Thread.Sleep(1000); _switch.Reset(false);
             * SyncU3D sync = new SyncU3D() { type = eSyncU3D.Switch, number = 1, Operate = true };
             * OnSync?.Invoke(this, sync);
             * Status = eProductionStageState.Ready;
             * //while (eHuiJinYunStagePosition.Peptization != context.Position) Thread.Sleep(1000);
             * //_switch.Switch();
             */
            context.CurrentAGV.State = eHuiJinYunAGVState.Mould;
            Status = eProductionStageState.Finish;

            result = null;
#if DEBUG
            Logger.LogInfo($"PeptizationStage Finish");
#endif
            return(this);
        }
Ejemplo n.º 2
0
        public IProductionStage Bypass(object args, out object result)
        {
            var context = (HuiJinYunProductionContext)args;

            Status = eProductionStageState.Ready;

            /*
             * new NotifyWatcher(_switch).WaitOne((s, a) => eHuiJinYunStagePosition.Peptization == context.Position, 1000);
             * _switch.Switch();
             * Thread.Sleep(10000);
             * new NotifyWatcher(_switch).WaitOne((s, a) => { return Bit.Tst(_switch.Status, eSwitchState.SwitchEnd); }, 1000);*/
            context.CurrentAGV.State = eHuiJinYunAGVState.Tray;
            Status = eProductionStageState.Finish;
            result = null;
            return(this);
        }
Ejemplo n.º 3
0
        public IProductionStage Work(object args, out object result)
        {
            var context = (HuiJinYunProductionContext)args;

            if (null != _runningTask)
            {
                _runningTask.Wait();
            }
            new NotifyWatcher(context).WaitOne((s, a) => eHuiJinYunStagePosition.Enlace == context.Position, 1000);
            _switch.Switch();

            _runningTask = Task.Run(() =>
            {
                Status = eProductionStageState.Ready;
                context.CurrentAGV.State = eHuiJinYunAGVState.Product;
                Status = eProductionStageState.Finish;
            });

            result = null;
            return(this);
        }
Ejemplo n.º 4
0
        public IProductionStage Work(object args, out object result)
        {
            Update(args);

            var context        = (HuiJinYunProductionContext)args;
            var switchWatcher  = new NotifyWatcher(_switch);
            var longmenWatcher = new NotifyWatcher(_longmen);
            var enlaceWatcher  = new NotifyWatcher(_enlace);
            var crswitch       = new NotifyWatcher(_crswitch);

#if DEBUG
            Logger.LogInfo($"EncapsulationStage Start");
#endif

            //(包胶周转台) 工控控制
            _switch.Operate(false); Thread.Sleep(100);
            _crswitch.Operate(false);

            _switch.EStop(true); Thread.Sleep(2000);
            _switch.EStop(false);

            _crswitch.Clamp(3, true); Thread.Sleep(2000);
            _crswitch.Clamp(3, false); Thread.Sleep(100);

            //(周转台) 输出取盘命令
            _crswitch.Clamp(1, true);

            Bit.Clr(_crswitch.Status, eSwitchState.Clamped0);
            //(缠绕六工位) 检测取盘完成
            while (!Bit.Tst(_crswitch.Status, eSwitchState.Clamped0))
            {
                Thread.Sleep(2000);
            }

            //(周转台) 输出取盘命令  关闭
            _crswitch.Clamp(1, false);


            for (int i = 0; i < 6; i++)
            //for (int i = 0; i <= 3; i++)
            //for (int i = 0; i < 1; i++)
            {
                _enlace.Reset(true); Thread.Sleep(100);
                _enlace.Reset(false);
                #region Encapsulation longmen
                if (i < 6)
                //if (i < 3)
                //if (i < 1)
                {
                    _longmen.BeginPickup(0);
                    while (!Bit.Tst(_longmen.Status, eLongMenState.InitialPickup))
                    {
                        Thread.Sleep(1000);
                    }

                    _switch.Clamp(i, true);
                    switch (i)
                    {
                    case 0:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped0);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped0))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 1:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped1);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped1))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 2:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped2);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped2))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 3:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped3);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped3))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 4:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped4);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped4))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 5:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped5);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped5))
                        {
                            Thread.Sleep(1000);
                        }
                        break;
                    }

                    _longmen.EndPickup(0);

                    while (!Bit.Tst(_longmen.Status, eLongMenState.InitialReady))
                    {
                        Thread.Sleep(1000);
                    }


                    //选择工位
                    while (context.EncapsulationDevice.Count < 1)
                    {
                        ;
                    }
                    Thread.Sleep(1000);

                    Encapsulation en = context.EncapsulationDevice[0];

                    //_enlace.Reset(true); Thread.Sleep(100);
                    //_enlace.Reset(false);

                    //(龙门) 输出工位信号和工位等待信号(PC-O0)
                    _longmen.BeginPlace(en.Id + 1, 1);

                    while (!Bit.Tst(_longmen.Status, eLongMenState.StationPickUp))
                    {
                        Thread.Sleep(1000);
                    }

                    //(包胶机) 包胶机卡盘松爪
                    _warps[en.Id].Placing(true); Thread.Sleep(3000);

                    //(龙门) 取件完成信号(PC-O14)
                    _longmen.EndPlace(en.Id + 1, 1); Thread.Sleep(100);

                    //(包胶机) 龙门夹件完成
                    _warps[en.Id].Clamped(true); Thread.Sleep(3000);
                    _warps[en.Id].Clamped(false);


                    //(龙门) 检测工位卡盘开爪(PC-I4)
                    while (!Bit.Tst(_longmen.Status, eLongMenState.StationClampOpen))
                    {
                        Thread.Sleep(1000);
                    }

                    //(龙门)卡盘开爪完成信号(PC-O15)
                    _longmen.EndPlace(en.Id + 1, 2); Thread.Sleep(3000);

                    //(龙门)卡盘可以闭爪(PC-I5)
                    _warps[en.Id].Placing(false); Thread.Sleep(2000);

                    //(龙门)卡盘闭爪完成信号(PC-O16)
                    _longmen.EndPlace(en.Id + 1, 3);

                    _warps[en.Id].EStop(true); Thread.Sleep(1000);

                    _warps[en.Id].EStop(false);

                    while (!Bit.Tst(_longmen.Status, eLongMenState.StationReady))
                    {
                        Thread.Sleep(1000);
                    }

                    //(周转台) 输出气缸松开爪信号
                    _switch.Clamp(i, true);
                    switch (i)
                    {
                    case 0:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped0);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped0))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 1:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped1);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped1))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 2:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped2);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped2))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 3:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped3);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped3))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 4:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped4);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped4))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 5:
                        Bit.Clr(_switch.Status, eSwitchState.Unclamped5);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped5))
                        {
                            Thread.Sleep(1000);
                        }
                        break;
                    }

                    _longmen.BeginPlace(en.Id + 1, 2);
                    while (!Bit.Tst(_longmen.Status, eLongMenState.StationPlace))
                    {
                        Thread.Sleep(1000);
                    }

                    _switch.Clamp(i, false);
                    switch (i)
                    {
                    case 0:
                        Bit.Clr(_switch.Status, eSwitchState.Clamped0);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Clamped0))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 1:
                        Bit.Clr(_switch.Status, eSwitchState.Clamped1);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Clamped1))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 2:
                        Bit.Clr(_switch.Status, eSwitchState.Clamped2);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Clamped2))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 3:
                        Bit.Clr(_switch.Status, eSwitchState.Clamped3);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Clamped3))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 4:
                        Bit.Clr(_switch.Status, eSwitchState.Clamped4);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Clamped4))
                        {
                            Thread.Sleep(1000);
                        }
                        break;

                    case 5:
                        Bit.Clr(_switch.Status, eSwitchState.Clamped5);
                        while (!Bit.Tst(_switch.Status, eSwitchState.Clamped5))
                        {
                            Thread.Sleep(1000);
                        }
                        break;
                    }
                    _longmen.EndPlace(i + 1, 4);

                    //_warps[en.Id].EStop(true); Thread.Sleep(1000);

                    //_warps[en.Id].EStop(false);
                    Thread.Sleep(1000);
                    //移除操作工位
                    context.EncapsulationDevice.Remove(en);
                }

                while (!Bit.Tst(_longmen.Status, eLongMenState.InitialStation))
                {
                    Thread.Sleep(1000);
                }
                #endregion

                if (i <= 5)
                {
                    //(周转台) 输出气工位旋转
                    _switch.Rotate(); Thread.Sleep(10000);

                    Bit.Clr(_switch.Status, eSwitchState.Rotate);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Rotate))
                    {
                        Thread.Sleep(1000);
                    }
                }

                //(周转台) 输出气工位旋转信号 关闭
                _switch.Rotate(false);

                #region Enlace

                _enlace.RevolvingDiscInPlace(); Thread.Sleep(3000);

                //if (i < 1)
                //{
                //    if (context.isStart)
                //    {
                //        //(缠绕机) 输出启动
                //        _enlace.Start(); Thread.Sleep(1000);
                //        context.isStart = false;
                //    }
                //}

                //(缠绕机) 输出周转盘旋转到位 信号取消
                _enlace.RevolvingDiscInPlace(false); Thread.Sleep(100);

                Bit.Clr(_enlace.Status, eEnlaceState.TurntableUndone);
                while (!Bit.Tst(_enlace.Status, eEnlaceState.TurntableUndone))
                {
                    Thread.Sleep(1000);
                }

                //(周转台) 输出气缸松开爪信号
                _switch.Clamp(i, true);
                switch (i)
                {
                case 0:
                    Bit.Clr(_switch.Status, eSwitchState.Unclamped0);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped0))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 1:
                    Bit.Clr(_switch.Status, eSwitchState.Unclamped1);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped1))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 2:
                    Bit.Clr(_switch.Status, eSwitchState.Unclamped2);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped2))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 3:
                    Bit.Clr(_switch.Status, eSwitchState.Unclamped3);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped3))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 4:
                    Bit.Clr(_switch.Status, eSwitchState.Unclamped4);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped4))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 5:
                    Bit.Clr(_switch.Status, eSwitchState.Unclamped5);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Unclamped5))
                    {
                        Thread.Sleep(1000);
                    }
                    break;
                }

                _enlace.UnRevolvingDisc(); Thread.Sleep(1000);

                //(缠绕机) 检测周转盘夹紧
                Bit.Clr(_enlace.Status, eEnlaceState.TurntableClamping);

                while (!Bit.Tst(_enlace.Status, eEnlaceState.TurntableClamping))
                {
                    Thread.Sleep(1000);
                }

                //(缠绕机) 输出周转盘夹紧
                _switch.Clamp(i, false);

                switch (i)
                {
                case 0:
                    Bit.Clr(_switch.Status, eSwitchState.Clamped0);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Clamped0))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 1:
                    Bit.Clr(_switch.Status, eSwitchState.Clamped1);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Clamped1))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 2:
                    Bit.Clr(_switch.Status, eSwitchState.Clamped2);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Clamped2))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 3:
                    Bit.Clr(_switch.Status, eSwitchState.Clamped3);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Clamped3))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 4:
                    Bit.Clr(_switch.Status, eSwitchState.Clamped4);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Clamped4))
                    {
                        Thread.Sleep(1000);
                    }
                    break;

                case 5:
                    Bit.Clr(_switch.Status, eSwitchState.Clamped5);
                    while (!Bit.Tst(_switch.Status, eSwitchState.Clamped5))
                    {
                        Thread.Sleep(1000);
                    }
                    break;
                }

                _enlace.TurntableClampingReady();

                //(缠绕机) 周转盘旋转信号
                Bit.Clr(_enlace.Status, eEnlaceState.RevolvingDiskRotation);
                while (!Bit.Tst(_enlace.Status, eEnlaceState.RevolvingDiskRotation))
                {
                    Thread.Sleep(1000);
                }

                //  旋转(缠绕六工位)
                _crswitch.Clamp(0, true); Thread.Sleep(2000);

                //(缠绕六工位) 周转盘旋转信号
                Bit.Clr(_crswitch.Status, eSwitchState.Unclamped0);
                Thread.Sleep(3000);
                while (!Bit.Tst(_crswitch.Status, eSwitchState.Unclamped0))
                {
                    Thread.Sleep(1000);
                }

                //  旋转(缠绕六工位)
                _crswitch.Clamp(0, false);
                #endregion

                //_enlace.Reset(true); Thread.Sleep(100);
                //_enlace.Reset(false);
            }

            /*
             * //  旋转(缠绕六工位)
             * _crswitch.Clamp(0, true); Thread.Sleep(2000);
             *
             * //(缠绕六工位) 周转盘旋转信号
             * while (!Bit.Tst(_crswitch.Status, eSwitchState.Unclamped0)) Thread.Sleep(100);
             *
             * //  旋转(缠绕六工位)
             * _crswitch.Clamp(0, false);
             */
            Thread.Sleep(10000);

            //(周转台) 输出放盘命令
            _crswitch.Clamp(2, true);
            Bit.Clr(_crswitch.Status, eSwitchState.Unclamped1);
            Thread.Sleep(3000);
            //(缠绕六工位) 周转盘旋转信号
            while (!Bit.Tst(_crswitch.Status, eSwitchState.Unclamped1))
            {
                Thread.Sleep(1000);
            }

            //(周转台) 输出放盘命令 关闭
            _crswitch.Clamp(2, false);

            // Encapsulation And Enlace End
            Status = eProductionStageState.Ready;
            context.CurrentAGV.State = eHuiJinYunAGVState.Tray;
            Status = eProductionStageState.Finish;

            result = null;
#if DEBUG
            Logger.LogInfo($"EncapsulationStage Finish");
#endif
            return(this);
        }