Example #1
0
        public void ParseStatus(string data)
        {
            bool pos_changed = false;

            string[] elements = data.TrimEnd('>').Split('|');

            if (elements.Length > 1)
            {
                string[] pair = elements[0].Split(':');
                SetGRBLState(pair[0].Substring(1), pair.Count() == 1 ? -1 : int.Parse(pair[1]), false);

                for (int i = elements.Length - 1; i > 0; i--)
                {
                    pair = elements[i].Split(':');

                    if (pair.Length == 2)
                    {
                        if (Set(pair[0], pair[1]))
                        {
                            pos_changed = true;
                        }
                    }
                }

                if (!data.Contains("|Pn:"))
                {
                    Set("Pn", "");
                }

                if (pos_changed)
                {
                    if (_isMPos)
                    {
                        if (has_wco)
                        {
                            Position.Set(MachinePosition - WorkPositionOffset);
                        }
                        else
                        {
                            Position.Set(MachinePosition);
                        }
                    }
                    else
                    {
                        if (has_wco)
                        {
                            MachinePosition.Set(WorkPosition + WorkPositionOffset);
                        }
                        Position.Set(WorkPosition);
                    }
                }
            }
        }
Example #2
0
        public void Set(string parameter, string value)
        {
            switch (parameter)
            {
            case "MPos":
                if (_MPos != value)
                {
                    if (!_isMPos)
                    {
                        IsMachinePosition = true;
                    }
                    _MPos = value;
                    MachinePosition.Parse(_MPos);
                    Position.Set(MachinePosition - WorkPositionOffset);
                }
                break;

            case "WPos":
                if (_WPos != value)
                {
                    if (_isMPos)
                    {
                        IsMachinePosition = false;
                    }
                    _WPos = value;
                    WorkPosition.Parse(_WPos);
                    MachinePosition.Set(WorkPosition + WorkPositionOffset);
                    Position.Set(WorkPosition);
                }
                break;

            case "A":
                if (_a != value)
                {
                    _a = value;

                    if (_a == "")
                    {
                        Mist = Flood = IsToolChanging = false;
                        SpindleState.Value = GCode.SpindleState.Off;
                    }
                    else
                    {
                        Mist               = value.Contains("M");
                        Flood              = value.Contains("F");
                        IsToolChanging     = value.Contains("T");
                        SpindleState.Value = value.Contains("S") ? GCode.SpindleState.CW : (value.Contains("C") ? GCode.SpindleState.CCW : GCode.SpindleState.Off);
                    }
                }
                break;

            case "WCO":
                if (_wco != value)
                {
                    _wco = value;
                    WorkPositionOffset.Parse(value);
                    if (_isMPos)
                    {
                        Position.Set(MachinePosition - WorkPositionOffset);
                    }
                    else
                    {
                        MachinePosition.Set(WorkPosition + WorkPositionOffset);
                    }
                }
                break;

            case "WCS":
                if (_wcs != value)
                {
                    WorkCoordinateSystem = GrblParserState.WorkOffset = value;
                }
                break;

            case "Bf":
                string[] buffers = value.Split(',');
                if (buffers[0] != _pb_avail)
                {
                    _pb_avail = buffers[0];
                    OnPropertyChanged(nameof(PlanBufferAvailable));
                }
                if (buffers[1] != _rxb_avail)
                {
                    _rxb_avail = buffers[1];
                    OnPropertyChanged(nameof(RxBufferAvailable));
                }
                break;

            case "Ln":
                LineNumber = int.Parse(value);
                break;

            case "FS":
                if (_fs != value)
                {
                    _fs = value;
                    if (_fs == "")
                    {
                        FeedRate = ProgrammedRPM = 0d;
                        if (!double.IsNaN(ActualRPM))
                        {
                            ActualRPM = 0d;
                        }
                    }
                    else
                    {
                        double[] values = dbl.ParseList(_fs);
                        if (_feedrate != values[0])
                        {
                            FeedRate = values[0];
                        }
                        if (_rpm != values[1])
                        {
                            ProgrammedRPM = values[1];
                        }
                        if (values.Length > 2 && _rpmActual != values[2])
                        {
                            ActualRPM = values[2];
                        }
                    }
                }
                break;

            case "F":
                if (_fs != value)
                {
                    _fs = value;
                    if (_fs == "")
                    {
                        FeedRate = ProgrammedRPM = 0d;
                        if (!double.IsNaN(ActualRPM))
                        {
                            ActualRPM = 0d;
                        }
                    }
                    else
                    {
                        FeedRate = dbl.Parse(_fs);
                    }
                }
                break;

            case "PWM":
                PWM = int.Parse(value);
                break;

            case "Pn":
                if (_pn != value)
                {
                    _pn = value;

                    int s = 0;
                    foreach (char c in _pn)
                    {
                        int i = GrblConstants.SIGNALS.IndexOf(c);
                        if (i >= 0)
                        {
                            s |= (1 << i);
                        }
                    }
                    Signals.Value = (Signals)s;
                }
                break;

            case "Ov":
                if (_ov != value)
                {
                    _ov = value;
                    if (_ov == string.Empty)
                    {
                        FeedOverride = RapidsOverride = RPMOverride = 100d;
                    }
                    else
                    {
                        double[] values = dbl.ParseList(_ov);
                        if (_feedOverride != values[0])
                        {
                            FeedOverride = values[0];
                        }
                        if (_rapidsOverride != values[1])
                        {
                            RapidsOverride = values[1];
                        }
                        if (_rpmOverride != values[2])
                        {
                            RPMOverride = values[2];
                        }
                    }
                }
                break;

            case "Sc":
                if (_sc != value)
                {
                    int s = 0;
                    foreach (char c in value)
                    {
                        int i = GrblInfo.AxisLetterToIndex(c);
                        if (i >= 0)
                        {
                            s |= (1 << i);
                        }
                    }
                    AxisScaled.Value = (AxisFlags)s;
                    Scaling          = value;
                }
                break;

            case "Ex":
                if (_ex != value)
                {
                    TubeCoolant = value == "C";
                }
                break;

            case "SD":
                value = string.Format("SD Card streaming {0}% complete", value.Split(',')[0]);
                if (SDCardStatus != value)
                {
                    Message = SDCardStatus = value;
                }
                break;

            case "T":
                if (_tool != value)
                {
                    Tool = GrblParserState.Tool = value == "0" ? GrblConstants.NO_TOOL : value;
                }
                break;

            case "MPG":
                GrblInfo.MPGMode = _grblState.MPG = value == "1";
                IsMPGActive      = _grblState.MPG;
                break;

            case "H":
                if (_h != value)
                {
                    _h = value;
                    var hs = _h.Split(',');
                    HomedState = hs[0] == "1" ? HomedState.Homed : (GrblState.State == GrblStates.Alarm && GrblState.Substate == 11 ? HomedState.NotHomed : HomedState.Unknown);
                }
                break;

            case "D":
                _d        = value;
                LatheMode = GrblParserState.LatheMode = value == "0" ? LatheMode.Radius : LatheMode.Diameter;
                break;
            }
        }