コード例 #1
0
        //https://social.technet.microsoft.com/wiki/contents/articles/21202.wpf-programmatically-selecting-and-focusing-a-row-or-cell-in-a-datagrid.aspx
        public async void SelectRowAsync(GcodeLine _gcodeline)
        {
            await Task.Run(() => Dispatcher.BeginInvoke(new Action(delegate()
            {
                // if (_gcodeline.InSerialBuffer)
                {
                    // GcodeGrid.SelectedItems.Clear();

                    object item = GcodeGrid.Items[_gcodeline.Index];

                    GcodeGrid.SelectedItem = item;

                    if (App.Grbl.InRunState)
                    {
                        GcodeGrid.ScrollIntoView(item);
                    }

                    //if (!(GcodeGrid.ItemContainerGenerator.ContainerFromIndex(_gcodeline.Index) is DataGridRow row))
                    //{
                    //    GcodeGrid.ScrollIntoView(item);
                    //    row = GcodeGrid.ItemContainerGenerator.ContainerFromIndex(_gcodeline.Index) as DataGridRow;
                    //}
                    ////row.Focus();
                    //DataGridCell cell = GetCell(row, 2);
                    //if (cell != null)
                    //{
                    //    cell.Focus();
                    //}
                }
            })));
        }
コード例 #2
0
        private void ProcessGcode()
        {
            bool takeabreak = false;

            while (GcodeIsRunning)
            {
                GcodeIsRunning = Gcode.Where(x => !x.IsProcessed).FirstOrDefault() != null;

                takeabreak = !InIdleState & !InCheckState & !InRunState;

                lock (Gcode) QueuedSize = Gcode.Where(x => !x.IsProcessed & x.InSerialBuffer).Sum(x => x.CommandLength);
                GcodeLine gcodeline = Gcode.Where(x => !x.IsProcessed & !x.InSerialBuffer).FirstOrDefault();

                while (gcodeline != null & !takeabreak && (GcodeIsRunning & ((rx_buffer_size - QueuedSize) >= gcodeline.CommandLength)))
                {
                    serialport.Write(Command.AddReturn(gcodeline.GrblCommand).ToString());
                    gcodeline.InSerialBuffer = true;
                    lock (Gcode) QueuedSize = Gcode.Where(x => !x.IsProcessed & x.InSerialBuffer).Sum(x => x.CommandLength);
                    gcodeline = Gcode.Where(x => !x.IsProcessed & !x.InSerialBuffer).FirstOrDefault();
                }
            }
        }
コード例 #3
0
        private void ProcessResponse(string _data, bool _iserror = false)
        {
            if (GcodeIsRunning)
            {
                GcodeLine gcodeline = Gcode.Where(x => x.Index == lastprocessedindex).First();
                gcodeline.InSerialBuffer = false;
                gcodeline.IsProcessed    = true;
                gcodeline.Response       = _iserror ? Error.Codes[_data.Split(':')[1]] : _data;
                GcodeLineChanged?.Invoke(gcodeline, new EventArgs());

                ++lastprocessedindex;
            }
            else
            {
                if (_iserror)
                {
                    ErrorReceived?.Invoke(this, new ErrorReceivedEventArgs(Error.Codes[_data.Split(':')[1]]));
                }
            }

            GetStatus();
        }
コード例 #4
0
        private void Grbl_GcodeLineChanged(object sender, EventArgs e)
        {
            GcodeLine gcodeline = (GcodeLine)sender;

            Vector3 frompoint   = new Vector3((float)(X0 + gcodeline.Xfrom), (float)(Y0 + gcodeline.Yfrom), (float)(Z0 + gcodeline.Zfrom));
            Vector3 topoint     = new Vector3((float)(X0 + gcodeline.Xto), (float)(Y0 + gcodeline.Yto), (float)(Z0 + gcodeline.Zto));
            Vector3 centerpoint = new Vector3((float)(X0 + gcodeline.Xcenter), (float)(Y0 + gcodeline.Ycenter), (float)(Z0 + gcodeline.Zcenter));

            if (!float.IsNaN(frompoint.X) & !float.IsNaN(frompoint.Y) & !float.IsNaN(frompoint.Z) & !float.IsNaN(topoint.X) & !float.IsNaN(topoint.Y) & !float.IsNaN(topoint.Z))
            {
                if (gcodeline.IsCuttingMotion)
                {
                    if (gcodeline.IsLinearMotion)
                    {
                        localprocessed.AddLine(frompoint, topoint);
                    }
                    else
                    {
                        ArcPointSegment(ref localprocessed, frompoint, topoint, centerpoint, (bool)gcodeline.IsCW);
                    }
                }
                else
                {
                    if (gcodeline.IsLinearMotion)
                    {
                        localprocessed.AddLine(frompoint, topoint);
                    }
                    else
                    {
                        ArcPointSegment(ref localprocessed, frompoint, topoint, centerpoint, (bool)gcodeline.IsCW);
                    }
                }
            }

            Processed = localprocessed.ToLineGeometry3D();
        }