Esempio n. 1
0
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            double g = -1;

            istruction.Parameters.TryGetValue('G', out g);

            var step = new MachineStep()
            {
                Id      = GetStepId(),
                Name    = $"G153 G{g}",
                Actions = new List <BaseAction>()
            };

            switch (g)
            {
            case 0:
                ConvertG0(istruction, state, step);
                break;

            case 1:
                ConvertG1(istruction, state, step);
                break;

            default:
                throw new NotImplementedException($"G153 G{g} not implemented!");
            }

            SetActionsIds(step);
            SetMaxDuration(step);

            return((step.Actions.Count() > 0) ? new List <MachineStep>()
            {
                step
            } : null);
        }
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            if (istruction.Parameters.TryGetValue('X', out double x))
            {
                var step = new MachineStep()
                {
                    Id      = GetStepId(),
                    Name    = $"G692",
                    Actions = new List <BaseAction>()
                };

                state.Axes.SetRapidX(x, step);
                SetActionsIds(step);
                SetMaxDuration(step);

                return(new List <MachineStep>()
                {
                    step
                });
            }
            else
            {
                return(null);
            }
        }
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            if (istruction.Parameters.TryGetValue('L', out double ln) && istruction.Parameters.TryGetValue('T', out double t))
            {
                MachineStep ms = null;

                if (t == 1.0)
                {
                    ms = GetMachineStepForBlowing(ln);
                }
                else if (t == 2.0)
                {
                    ms = GetMachineStepForGlue(ln);
                }
                else if (t == 3.0)
                {
                    //ms = GetMachineStepForDoweling(ln);
                    return(GetMachineStepsForDoweling(ln));
                }
                else
                {
                    throw new ArgumentOutOfRangeException("Invalid doweling operation!");
                }

                return((ms != null) && (ms.Actions.Count > 0) ? new List <MachineStep>()
                {
                    ms
                } : null);
            }
            else
            {
                return(null);
            }
        }
Esempio n. 4
0
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            var step = new MachineStep()
            {
                Id      = GetStepId(),
                Name    = $"G0",
                Actions = new List <BaseAction>()
            };

            if (istruction.Parameters != null && istruction.Parameters.Count > 0)
            {
                if (istruction.Parameters.TryGetValue('X', out double x))
                {
                    state.Axes.SetRapidX(x, step);
                }
                if (istruction.Parameters.TryGetValue('Y', out double y))
                {
                    state.Axes.SetRapidY(y, step);
                }
                if (istruction.Parameters.TryGetValue('Z', out double z))
                {
                    state.Axes.SetRapidZ(z, step);
                }

                SetActionsIds(step);
                SetMaxDuration(step);
            }

            return((step.Actions.Count() > 0) ? new List <MachineStep>()
            {
                step
            } : null);
        }
Esempio n. 5
0
        private void ManagePreviousSynchro(GIstruction istruction, State state, List <MachineStep> steps)
        {
            var step = new MachineStep()
            {
                Id      = GetStepId(),
                Name    = "G140 - Reset previous",
                Actions = new List <BaseAction>()
            };
            var resetX  = istruction.Parameters.Keys.Contains('X') && istruction.Parameters.Keys.Contains('U') && istruction.Parameters.Keys.Contains('I');
            var resetY  = istruction.Parameters.Keys.Contains('Y') && istruction.Parameters.Keys.Contains('V') && istruction.Parameters.Keys.Contains('J');
            var resetZ  = istruction.Parameters.Keys.Contains('Z') && istruction.Parameters.Keys.Contains('W') && istruction.Parameters.Keys.Contains('K');
            var resetZ2 = istruction.Parameters.Keys.Contains('A') && istruction.Parameters.Keys.Contains('B') && istruction.Parameters.Keys.Contains('K');

            if (resetX)
            {
                state.Axes.ResetGantryX(step);
            }
            if (resetY)
            {
                state.Axes.ResetGantryY(step);
            }

            if (resetZ || resetZ2)
            {
                state.Axes.ResetGantryZ(step);
                state.Axes.ResetGantryZ2(step);
            }

            if (step.Actions.Count > 0)
            {
                steps.Add(step);
            }
        }
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            var step = new MachineStep()
            {
                Id      = GetStepId(),
                Name    = "G3",
                Actions = new List <BaseAction>()
            };

            istruction.Parameters.TryGetValue('X', out double x);
            istruction.Parameters.TryGetValue('Y', out double y);
            istruction.Parameters.TryGetValue('I', out double i);
            istruction.Parameters.TryGetValue('J', out double j);
            if (istruction.Parameters.TryGetValue('F', out double v))
            {
                state.FeedSpeed = (int)v;
            }

            state.Axes.SetPosition(step, state.FeedSpeed, x, y, i, j, false);
            SetActionsIds(step);

            return((step.Actions.Count() > 0) ? new List <MachineStep>()
            {
                step
            } : null);
        }
Esempio n. 7
0
        private static void ConvertG1(GIstruction istruction, State state, MachineStep step)
        {
            var    x = new Nullable <double>();
            var    y = new Nullable <double>();
            var    z = new Nullable <double>();
            double v = 0.0;

            if (istruction.Parameters.TryGetValue('X', out v))
            {
                x = v;
            }
            if (istruction.Parameters.TryGetValue('Y', out v))
            {
                y = v;
            }
            if (istruction.Parameters.TryGetValue('Z', out v))
            {
                z = v;
            }
            if (istruction.Parameters.TryGetValue('F', out v))
            {
                state.FeedSpeed = (int)v;
            }

            state.Axes.SetPosition(step, state.FeedSpeed, x, y, z, false);
        }
Esempio n. 8
0
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            state.Axes.OX = istruction.Parameters['X'];
            state.Axes.OY = istruction.Parameters['Y'];
            state.Axes.OZ = istruction.Parameters['Z'];

            return(null);
        }
Esempio n. 9
0
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            var step = new MachineStep()
            {
                Id      = GetStepId(),
                Name    = $"G0",
                Actions = new List <BaseAction>()
            };

            if (istruction.Parameters != null && istruction.Parameters.Count > 0)
            {
                if (state.Axes.M.IsIdentity() || state.Axes.M.IsIdentityFlipped())
                {
                    if (istruction.Parameters.TryGetValue('X', out double x))
                    {
                        state.Axes.SetRapidX(x, step);
                    }
                    if (istruction.Parameters.TryGetValue('Y', out double y))
                    {
                        state.Axes.SetRapidY(y, step);
                    }
                    if (istruction.Parameters.TryGetValue('Z', out double z))
                    {
                        state.Axes.SetRapidZ(z, step);
                    }
                }
                else
                {
                    double?nx = null;
                    double?ny = null;
                    double?nz = null;

                    if (istruction.Parameters.TryGetValue('X', out double x))
                    {
                        nx = x;
                    }
                    if (istruction.Parameters.TryGetValue('Y', out double y))
                    {
                        ny = y;
                    }
                    if (istruction.Parameters.TryGetValue('Z', out double z))
                    {
                        nz = z;
                    }

                    state.Axes.SetRapid(nx, ny, nz, step);
                }

                SetActionsIds(step);
                SetMaxDuration(step);
            }

            return((step.Actions.Count() > 0) ? new List <MachineStep>()
            {
                step
            } : null);
        }
 public virtual List <MachineStep> Convert(GIstruction istruction, T state)
 {
     if (istruction == null)
     {
         throw new ArgumentNullException($"The istruction is not type {typeof(GIstruction).Name}");
     }
     Debug.WriteLine($"Convert method for G{istruction.Istruction} not implemented!");
     return(null);
 }
        private void OnGIstructionMessage(GIstructionMessage msg)
        {
            var istruction = new GIstruction(msg.Istruction, msg.Coordinates.ToDictionary(c => c.Key[0], c => c.Value))
            {
                LineNumber = msg.Step
            };
            var steps = _converterManager.Convert(istruction);

            if ((steps != null) && (steps.Count > 0))
            {
                MachineSteps.AddRange(steps);
            }
        }
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            if (istruction.Parameters.TryGetValue('L', out double length))
            {
                state.Axes.L = length;
            }
            if (istruction.Parameters.TryGetValue('R', out double radius))
            {
                state.Axes.R = radius;
            }

            return(null);
        }
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            var steps = new List <MachineStep>();

            for (int i = 0; i < state.ToolChange.NumSteps; i++)
            {
                bool openToolStore  = (i == 0);
                bool closeToolStore = (i == state.ToolChange.NumSteps - 1);

                steps.AddRange(CreateToolchangeStep(state, i, openToolStore, closeToolStore));
            }

            return((steps.Count() > 0) ? steps : null);
        }
Esempio n. 14
0
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            if (istruction.Parameters.TryGetValue('S', out double s))
            {
                if (s == 0.0)
                {
                    state.Axes.M.Reset();
                }
                else if (s == 1.0)
                {
                    if (istruction.Parameters.TryGetValue('I', out double i) &&
                        istruction.Parameters.TryGetValue('J', out double j) &&
                        istruction.Parameters.TryGetValue('K', out double k) &&
                        istruction.Parameters.TryGetValue('P', out double p) &&
                        istruction.Parameters.TryGetValue('Q', out double q) &&
                        istruction.Parameters.TryGetValue('R', out double r) &&
                        istruction.Parameters.TryGetValue('U', out double u) &&
                        istruction.Parameters.TryGetValue('V', out double v) &&
                        istruction.Parameters.TryGetValue('W', out double w) &&
                        istruction.Parameters.TryGetValue('M', out double m) &&
                        istruction.Parameters.TryGetValue('N', out double n) &&
                        istruction.Parameters.TryGetValue('O', out double o))
                    {
                        state.Axes.M.I = i;
                        state.Axes.M.J = j;
                        state.Axes.M.K = k;
                        state.Axes.M.P = p;
                        state.Axes.M.Q = q;
                        state.Axes.M.R = r;
                        state.Axes.M.U = u;
                        state.Axes.M.V = v;
                        state.Axes.M.W = w;
                        state.Axes.M.M = m;
                        state.Axes.M.N = n;
                        state.Axes.M.O = o;
                    }
                    else
                    {
                        throw new ArgumentException("Invalid parameters set in G305!");
                    }
                }
                else
                {
                    throw new ArgumentException("Parameter S in G305 invalid value!");
                }
            }

            return(null);
        }
Esempio n. 15
0
        private List <MachineStep> Convert(GIstruction istruction)
        {
            if (istruction == null)
            {
                throw new ArgumentNullException($"The istruction is not type {typeof(GIstruction).Name}");
            }

            if (_gIstructionConverters.TryGetValue(istruction.Istruction, out BaseIstructionConverter <State> c))
            {
                return(c.Convert(istruction, _state));
            }
            else
            {
                return(null);
            }
        }
Esempio n. 16
0
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            if (!IsSynchro(istruction))
            {
                var steps = new List <MachineStep>();

                ManagePreviousSynchro(istruction, state, steps);
                AddSynchroSteps(istruction, state, steps);

                return(steps);
            }
            else
            {
                return(null);
            }
        }
        private void ManageWaiter(GIstruction istruction, State state, List <MachineStep> steps)
        {
            var step = new MachineStep()
            {
                Id      = GetStepId(),
                Name    = "G140 - Synchro",
                Actions = new List <BaseAction>()
            };

            step.Actions.Add(new ChannelWaiterAction()
            {
                Name = "Waiter", Description = "Channel waiter", ChannelToWait = 1
            });

            steps.Add(step);
        }
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            if (istruction.Parameters.TryGetValue('G', out double g))
            {
                var step = new MachineStep()
                {
                    Id      = GetStepId(),
                    Name    = $"G141 G{g}",
                    Actions = new List <BaseAction>()
                };

                if (g == 1.0)
                {
                    state.Axes.ResetGantryX(step);
                }
                else if (g == 2.0)
                {
                    state.Axes.ResetGantryY(step);
                }
                else if (g == 3.0)
                {
                    state.Axes.ResetGantryZ(step);
                }
                else if (g == 4.0)
                {
                    state.Axes.ResetGantryZ2(step);
                }
                else
                {
                    state.Axes.ResetGantryX(step);
                    state.Axes.ResetGantryY(step);
                    state.Axes.ResetGantryZ(step);
                    state.Axes.ResetGantryZ2(step);
                }

                SetActionsIds(step);

                return((step.Actions.Count > 0) ? new List <MachineStep>()
                {
                    step
                } : null);
            }
            else
            {
                return(null);
            }
        }
        private void ManageNotOperation(GIstruction istruction, State state, List <MachineStep> steps)
        {
            if (steps.Count == 0)
            {
                var step = new MachineStep()
                {
                    Id      = GetStepId(),
                    Name    = "G140 - NOP",
                    Actions = new List <BaseAction>()
                };

                step.Actions.Add(new NotOperationAction()
                {
                    Name = "NOP", Description = "NOP to start"
                });

                steps.Add(step);
            }
        }
Esempio n. 20
0
        public static BaseIstruction Create(string data, int lineNumber)
        {
            BaseIstruction istruction = null;
            var            indexRegEx = new Regex("G\\d+");

            if (indexRegEx.IsMatch(data))
            {
                var matchStr = indexRegEx.Match(data).Value;
                var sIndex   = matchStr.Remove(0, 1);

                if (int.TryParse(sIndex, out int index))
                {
                    var parameters = ParseParameters(data.Replace(matchStr, string.Empty));
                    istruction            = new GIstruction(index, parameters);
                    istruction.LineNumber = lineNumber;
                }
            }

            return(istruction);
        }
Esempio n. 21
0
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            var step = new MachineStep()
            {
                Id      = GetStepId(),
                Name    = $"G1",
                Actions = new List <BaseAction>()
            };

            var    x = new Nullable <double>();
            var    y = new Nullable <double>();
            var    z = new Nullable <double>();
            double v = 0.0;

            if (istruction.Parameters.TryGetValue('X', out v))
            {
                x = v;
            }
            if (istruction.Parameters.TryGetValue('Y', out v))
            {
                y = v;
            }
            if (istruction.Parameters.TryGetValue('Z', out v))
            {
                z = v;
            }
            if (istruction.Parameters.TryGetValue('F', out v))
            {
                state.FeedSpeed = (int)v;
            }

            state.Axes.SetPosition(step, state.FeedSpeed, x, y, z);
            SetActionsIds(step);

            return((step.Actions.Count() > 0) ? new List <MachineStep>()
            {
                step
            } : null);
        }
        public override List <MachineStep> Convert(GIstruction istruction, State state)
        {
            var step = new MachineStep()
            {
                Id      = GetStepId(),
                Name    = "G210",
                Actions = new List <BaseAction>()
            };

            var x = new Nullable <double>();
            var y = new Nullable <double>();
            var z = new Nullable <double>();

            if (istruction.Parameters.TryGetValue('X', out double v))
            {
                x = v;
            }
            if (istruction.Parameters.TryGetValue('Y', out v))
            {
                y = v;
            }
            if (istruction.Parameters.TryGetValue('Z', out v))
            {
                z = v;
            }

            // la tastatura azzera la G161
            state.Axes.OX = 0.0;
            state.Axes.OY = 0.0;
            //state.Axes.OZ = 0.0; // dalle prove fatte sembra che sulla Z debba rimanere l'effetto G161 (???)

            state.Axes.SetPosition(step, 500, x, y, z);

            return((step.Actions.Count() > 0) ? new List <MachineStep>()
            {
                step
            } : null);
        }
Esempio n. 23
0
        private static void ConvertG0(GIstruction istruction, State state, MachineStep step)
        {
            if (state.Axes.GantryX == StateData.Gantry.None)
            {
                var moveX = istruction.Parameters.TryGetValue('X', out double x);
                var moveU = istruction.Parameters.TryGetValue('U', out double u);

                if (moveX && moveU)
                {
                    state.Axes.SetXU(x, u, step, false);
                }
                else if (moveX)
                {
                    state.Axes.SetX(x, step, false);
                }
                else if (moveU)
                {
                    state.Axes.SetU(u, step, false);
                }
            }
            else
            {
                if (istruction.Parameters.TryGetValue('X', out double x))
                {
                    state.Axes.SetRapidX(x, step, false);
                }
            }

            if (state.Axes.GantryY == StateData.Gantry.None)
            {
                var moveY = istruction.Parameters.TryGetValue('Y', out double y);
                var moveV = istruction.Parameters.TryGetValue('V', out double v);

                if (moveY && moveV)
                {
                    state.Axes.SetYV(y, v, step, false);
                }
                else if (moveY)
                {
                    state.Axes.SetY(y, step, false);
                }
                else if (moveV)
                {
                    state.Axes.SetV(v, step, false);
                }
            }
            else
            {
                if (istruction.Parameters.TryGetValue('Y', out double y))
                {
                    state.Axes.SetRapidY(y, step, false);
                }
            }

            if ((state.Axes.GantryZ == StateData.Gantry.None) && (state.Axes.GantryZ2 == StateData.Gantry.None))
            {
                var moveZ = istruction.Parameters.TryGetValue('Z', out double z);
                var moveW = istruction.Parameters.TryGetValue('W', out double w);
                var moveA = istruction.Parameters.TryGetValue('A', out double a);
                var moveB = istruction.Parameters.TryGetValue('B', out double b);

                if (moveZ && moveW && moveA && moveB)
                {
                    state.Axes.SetZWAB(z, w, a, b, step, false);
                }
                else if (moveZ && moveW)
                {
                    state.Axes.SetZW(z, w, step, false);
                }
                else if (moveA && moveB)
                {
                    state.Axes.SetAB(a, b, step, false);
                }
                else if (moveZ)
                {
                    state.Axes.SetZ(z, step, false);
                }
                else if (moveW)
                {
                    state.Axes.SetW(w, step, false);
                }
                else if (moveA)
                {
                    state.Axes.SetA(a, step, false);
                }
                else if (moveB)
                {
                    state.Axes.SetB(b, step, false);
                }
            }
            else
            {
                if (istruction.Parameters.TryGetValue('Z', out double z))
                {
                    state.Axes.SetRapidZ(z, step, false);
                }
            }
        }
Esempio n. 24
0
 private bool IsSynchro(GIstruction istruction)
 {
     return((istruction.Parameters != null) && istruction.Parameters.Keys.Contains('S'));
 }
Esempio n. 25
0
        private void AddSynchroSteps(GIstruction istruction, State state, List <MachineStep> steps)
        {
            var moveStepXY = new MachineStep()
            {
                Id = GetStepId(), Name = "G140 - Move XY", Actions = new List <BaseAction>()
            };
            var moveStepZ = new MachineStep()
            {
                Id = GetStepId(), Name = "G140 - Move Z", Actions = new List <BaseAction>()
            };
            var synStep = new MachineStep()
            {
                Id = GetStepId(), Name = "G140 - Gantry", Actions = new List <BaseAction>()
            };
            bool invertOrder = false;

            if (istruction.Parameters.Keys.Contains('H'))
            {
                var h = istruction.Parameters['H'];

                if (h == 2.0)
                {
                    invertOrder = true;
                }
            }

            if (istruction.Parameters.Keys.Contains('X') && istruction.Parameters.Keys.Contains('U') && istruction.Parameters.Keys.Contains('I'))
            {
                var x  = istruction.Parameters['X'];
                var u  = istruction.Parameters['U'];
                var i  = istruction.Parameters['I'];
                var vs = false;

                if (x == _parkValue)
                {
                    state.Axes.GetParkX(ref x); vs = true;
                }
                if (u == _parkValue)
                {
                    state.Axes.GetParkU(ref u); vs = true;
                }
                state.Axes.SetXU(x, u, moveStepXY, false);
                state.Axes.SetGantryX(i, synStep, vs);
            }

            if (istruction.Parameters.Keys.Contains('Y') && istruction.Parameters.Keys.Contains('V') && istruction.Parameters.Keys.Contains('J'))
            {
                var y  = istruction.Parameters['Y'];
                var v  = istruction.Parameters['V'];
                var j  = istruction.Parameters['J'];
                var vs = false;

                if (y == _parkValue)
                {
                    state.Axes.GetParkY(ref y); vs = true;
                }
                if (v == _parkValue)
                {
                    state.Axes.GetParkV(ref v); vs = true;
                }
                state.Axes.SetYV(y, v, moveStepXY, false);
                state.Axes.SetGantryY(j, synStep, vs);
            }

            if (istruction.Parameters.Keys.Contains('K'))
            {
                var parkZ = false;
                var parkW = false;
                var parkA = false;
                var parkB = false;

                if (istruction.Parameters.Keys.Contains('Z') && istruction.Parameters.Keys.Contains('W'))
                {
                    var z = istruction.Parameters['Z'];
                    var w = istruction.Parameters['W'];

                    if (z == _parkValue)
                    {
                        state.Axes.GetParkZ(ref z); parkZ = true;
                    }
                    if (w == _parkValue)
                    {
                        state.Axes.GetParkW(ref w); parkW = true;
                    }
                    state.Axes.SetZW(z, w, moveStepZ, false);
                }

                if (istruction.Parameters.Keys.Contains('A') && istruction.Parameters.Keys.Contains('B'))
                {
                    var a = istruction.Parameters['A'];
                    var b = istruction.Parameters['B'];

                    if (a == _parkValue)
                    {
                        state.Axes.GetParkA(ref a); parkA = true;
                    }
                    if (b == _parkValue)
                    {
                        state.Axes.GetParkB(ref b); parkB = true;
                    }
                    state.Axes.SetAB(a, b, moveStepZ, false);
                }

                var k  = istruction.Parameters['K'];
                var vs = false;

                if (((k == 1) || (k == 2)) && (parkZ || parkW))
                {
                    vs = true;
                }
                else if (((k == 3) || (k == 4)) && (parkA || parkB))
                {
                    vs = true;
                }

                state.Axes.SetGantryZ(k, synStep, vs);
            }

            SetActionsIds(moveStepXY);
            SetActionsIds(moveStepZ);
            SetActionsIds(synStep);

            if (invertOrder)
            {
                if (moveStepZ.Actions.Count > 0)
                {
                    steps.Add(moveStepZ);
                }
                if (moveStepXY.Actions.Count > 0)
                {
                    steps.Add(moveStepXY);
                }
            }
            else
            {
                if (moveStepXY.Actions.Count > 0)
                {
                    steps.Add(moveStepXY);
                }
                if (moveStepZ.Actions.Count > 0)
                {
                    steps.Add(moveStepZ);
                }
            }

            if (synStep.Actions.Count > 0)
            {
                steps.Add(synStep);
            }
        }