Пример #1
0
        private void Button2_Click(object sender, EventArgs e)
        {
            string src = File.ReadAllText(file);

            var          lexer  = new Lexer(src);
            List <Token> tokens = lexer.Tokenize().ToList();

            var         parser = new Parser(tokens);
            List <Code> gcodes = parser.Parse().ToList();

            MessageBox.Show("File Loaded");
            foreach (var code in gcodes)
            {
                string test = code.ToString();
                if (!test.Equals("Gcodes.Ast.Mcode"))
                {
                    Gcode           tempCode = (Gcode)code;
                    List <Argument> args     = tempCode.args;
                    string          output   = tempCode.ToString().Substring(0, 2) + " ";
                    foreach (var arg in args)
                    {
                        output = output + arg.Kind.ToString() + " " + arg.Value.ToString() + " ";
                    }
                    listBox1.Items.Add(output);
                }
            }
        }
        public CodeEditorViewTemplate(int tabId, Gcode file = null)
        {
            InitializeComponent();
            _viewModel = new CodeEditorViewModel(tabId, file);

            DataContext = _viewModel;
        }
Пример #3
0
        public void Connect()
        {
            if (serialPort != null)
            {
                Disconnect();
            }
            else
            {
                serialPort = new SerialPort(port, baud);
            }

            if (port != null)
            {
                serialPort.ReadTimeout  = 1000;
                serialPort.WriteTimeout = 1000;

                serialPort.Open();

                if (serialPort.IsOpen)
                {
                    WaitFor("wait", 5000);
                    Send(Gcode.ParseLine("M117 PrintSharp"));
                    WaitFor("ok 0", 5000);
                }
                else
                {
                    throw new Exception("Failed to open COM port " + port);
                }
            }
            else
            {
                throw new Exception("Cannot connect to NULL port");
            }
        }
Пример #4
0
        /// <summary>
        /// Get the <see cref="IOperation"/> corresponding to a particular
        /// <see cref="Gcode"/>.
        /// </summary>
        /// <param name="code"></param>
        /// <param name="initialState"></param>
        /// <returns></returns>
        public virtual IOperation GcodeOp(Gcode code, MachineState initialState)
        {
            Exception ex;

            if (ignoredGcodes.Contains(code.Number))
            {
                return(new Noop(initialState));
            }

            switch (code.Number)
            {
            case 4:
                var ms = code.ValueFor(ArgumentKind.P);
                if (ms == null)
                {
                    ex = new ArgumentException("Dwell commands require a P argument");
                    ex.Data[nameof(code)] = code;
                    throw ex;
                }
                return(new Noop(initialState, TimeSpan.FromMilliseconds(ms.Value)));

            default:
                ex = new UnknownGcodeException($"No applicable operation for G{code.Number}");
                ex.Data[nameof(code)] = code;
                throw ex;
            }
        }
Пример #5
0
        private void cmdDuplicateAll_Click(object sender, RoutedEventArgs e)
        {
            if (gCodeObject.gCodeList.Count < 1)
            {
                return;
            }

            double distXDir = HelperClass.ShowInputBox("Distance between Macros in X Direction");
            int    numXDir  = Convert.ToInt32(HelperClass.ShowInputBox("Number of Macros in X Direction"));
            double distYDir = HelperClass.ShowInputBox("Distance between Macros in Y Direction");
            int    numYDir  = Convert.ToInt32(HelperClass.ShowInputBox("Number of Macros in Y Direction"));

            List <Gcode> DuplicatedList = new List <Gcode>();

            foreach (Gcode item in gCodeObject.gCodeList)
            {
                Gcode gcodeToCopy = CloneClass.CloneObject <Gcode>(item);
                DuplicatedList.Add(gcodeToCopy);
                double distX = item.xStart;
                double distY = item.yStart;

                double distYDirFixed = distYDir;

                for (int x = 0; x <= numXDir; x++)
                {
                    for (int y = 1; y < numYDir; y++)
                    {
                        distY += distYDirFixed;

                        Gcode copyY = CloneClass.CloneObject <Gcode>(gcodeToCopy);

                        copyY.xStart = distX;
                        copyY.yStart = distY;

                        DuplicatedList.Add(copyY);
                    }

                    distYDirFixed *= -1;

                    distX += distXDir;

                    if (x >= numXDir - 1)
                    {
                        break;
                    }

                    Gcode copyX = CloneClass.CloneObject <Gcode>(gcodeToCopy);

                    copyX.xStart = distX;
                    copyX.yStart = distY;

                    DuplicatedList.Add(copyX);
                }
            }

            gCodeObject.gCodeList = DuplicatedList;

            gCodeObject.DrawObjects(ref MainCanvas, ref MainCanvasScale, ref GCodeView, ref Arrow, xMeasure, yMeasure);
        }
        public async Task <List <LineBuilder> > BuildGcodeLayerModelListAsync(Gcode gcode, IProgress <int> prog)
        {
            gcode.IsWorking = true;
            var lineBuilders = new List <LineBuilder>();
            SortedDictionary <double, LineBuilder> gcodeLayers = new SortedDictionary <double, LineBuilder>();

            try
            {
                var Commands = gcode.Commands;
                await Task.Run(() =>
                {
                    try
                    {
                        var temp = new List <LinesVisual3D>();
                        int i    = 0;
                        foreach (List <GcodeCommandLine> commands in Commands)
                        {
                            double z = gcode.ZHeights.Keys.ElementAt(i);

                            Application.Current.Dispatcher.Invoke((() =>
                            {
                                LineBuilder builder = BuildLineFromCommands(commands, z);
                                gcodeLayers.Add(z, builder);
                            }));

                            if (prog != null)
                            {
                                double test = (((double)i / Commands.Count) * 100f);
                                if (i < Commands.Count - 1)
                                {
                                    prog.Report(Convert.ToInt32(test));
                                }
                                else
                                {
                                    prog.Report(100);
                                }
                            }
                            i++;
                        }
                    }
                    catch (Exception exc)
                    {
                        logger.Error(string.Format(Strings.EventExceptionOccurredFormated, exc.TargetSite, exc.Message));
                    }
                });

                Application.Current.Dispatcher.Invoke(() =>
                {
                    gcode.LayerModelGenerated = true;
                    lineBuilders = gcodeLayers.Select(pair => pair.Value).ToList();
                });
            }
            catch (Exception exc)
            {
                logger.Error(string.Format(Strings.EventExceptionOccurredFormated, exc.TargetSite, exc.Message));
            }
            gcode.IsWorking = false;
            return(lineBuilders);
        }
Пример #7
0
        private bool LoadStlFile(string filename)
        {
            this.stl_file = filename;

            if (!File.Exists(filename))
            {
                pictureBox1.Image = null;
                return(false);
            }

            int w    = 2400;
            int h    = 1600;
            int xdiv = 12;
            int ydiv = 8;

            //slice
            Stopwatch sw   = Stopwatch.StartNew();
            Mesh      mesh = new Mesh(filename);

            Console.WriteLine("load stl: {0} ms", sw.ElapsedMilliseconds); sw.Restart();
            mesh.ShiftCenter();
            mesh.Scale(appset.stl_scale);
            Console.WriteLine("shift/scale stl: {0} ms", sw.ElapsedMilliseconds); sw.Restart();
            //float zstep = (mesh.zmax - mesh.zmin) / (xdiv * ydiv);
            float zstep = appset.zstep;

            slices = new Slices(mesh, zstep, appset.slice_tol, appset.z_angle * (float)Math.PI / 180f);
            Console.WriteLine("total slicing: {0} ms", sw.ElapsedMilliseconds); sw.Restart();

            //visualize
            Visualize vis = new Visualize(w, h);

            pictureBox1.Image = vis.show_Slices(slices, xdiv, ydiv);
            Console.WriteLine("visualize: {0} ms", sw.ElapsedMilliseconds); sw.Restart();

            //gcode
            gcode                  = new Gcode();
            gcode.ZStep            = appset.zstep;
            gcode.header           = appset.gcode_header;
            gcode.footer           = appset.gcode_footer;
            gcode.WallThickness    = appset.WallThickness;
            gcode.FilamentDiameter = appset.FilamentDiameter;
            gcode.PrintSpeed       = appset.PrintSpeed;
            gcode.PrintPerimeter   = appset.PrintPerimeter;
            gcode.Append(slices);
            Console.WriteLine("gcode: {0} ms", sw.ElapsedMilliseconds); sw.Restart();

            //show info
            txtInfo.Text =
                gcode.info().Replace(";", "").Replace("\n", "\r\n") +
                mesh.ToString() + "\r\n" +
                string.Format("Mesh Facets    {0:0.}\r\n", mesh.Facets.Length) +
                string.Format("Layers         {0:0.}\r\n", slices.slices.Count) +
                string.Format("Line Segments  {0:0.}\r\n", slices.LineSegmentCount());

            //clear settings isdirty flag
            appset.IsDirtyClearFlag();
            return(true);
        }
Пример #8
0
        public void BoringGcode()
        {
            var src    = "G01";
            var parser = new Parser(src);

            var got = parser.ParseGCode();

            var shouldBe = new Gcode(1, new List <Argument>(), new Span(0, src.Length));

            Assert.Equal(shouldBe, got);
        }
Пример #9
0
        public void RecogniseADwell()
        {
            var duration = 5;
            var code     = new Gcode(4, new List <Argument> {
                new Argument(ArgumentKind.P, duration * 1000, Span.Empty)
            }, Span.Empty);
            var shouldBe = new Noop(initialState, duration);

            var got = operations.GcodeOp(code, initialState);

            Assert.Equal(shouldBe, got);
        }
Пример #10
0
        static void Main(string[] args)
        {
            string raw = "G1 F900 X49.728 Y37.435 E2.17868 ;Test";

            Command command = Gcode.ParseLine(raw);

            command.Debug = true;

            Console.WriteLine(command.ToString());

            Console.ReadLine();
        }
Пример #11
0
        public void StartProcessingGcode()
        {
            if (Gcode != null & (InIdleState | InCheckState))
            {
                rx_buffer_size = Convert.ToInt16(ConfigurationManager.AppSettings["CommandBufferCapacity"]);
                Gcode.Reset();
                GcodeIsRunning     = true;
                lastprocessedindex = 0;
                QueuedSize         = 0;

                Task.Run(() => ProcessGcode());
            }
        }
Пример #12
0
        public void TestGcodeParseline()
        {
            string raw = "G1 F900 X49.728 Y37.435 E2.17868 ;Test";

            Command command = Gcode.ParseLine(raw);

            Assert.AreEqual(command.Text, raw);
            Assert.AreEqual(command.Code, "G1");
            Assert.AreEqual(command.Comment, "Test");
            Assert.AreNotEqual(command.Parameters, null);
            Assert.AreEqual(command.Parameters.Length, 4);
            Assert.AreEqual(command.Parameters[0], "F900");
            Assert.AreEqual(command.Parameters[1], "X49.728");
            Assert.AreEqual(command.Parameters[2], "Y37.435");
            Assert.AreEqual(command.Parameters[3], "E2.17868");
        }
Пример #13
0
        private void DuplicateGcode(double distXDir, int numXDir, double distYDir, int numYDir, int index)
        {
            Gcode gcodeToCopy = CloneClass.CloneObject <Gcode>(gCodeObject.gCodeList[index]);

            double distX = gCodeObject.gCodeList[index].xStart;
            double distY = gCodeObject.gCodeList[index].yStart;

            for (int x = 0; x <= numXDir; x++)
            {
                for (int y = 1; y < numYDir; y++)
                {
                    distY += distYDir;

                    Gcode copyY = CloneClass.CloneObject <Gcode>(gcodeToCopy);

                    copyY.xStart = distX;
                    copyY.yStart = distY;

                    gCodeObject.gCodeList.Add(copyY);
                }

                distYDir *= -1;

                distX += distXDir;

                if (x >= numXDir - 1)
                {
                    break;
                }

                Gcode copyX = CloneClass.CloneObject <Gcode>(gcodeToCopy);

                copyX.xStart = distX;
                copyX.yStart = distY;

                gCodeObject.gCodeList.Add(copyX);
            }

            gCodeObject.DrawObjects(ref MainCanvas, ref MainCanvasScale, ref GCodeView, ref Arrow, xMeasure, yMeasure);
        }
Пример #14
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();
        }
Пример #15
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();
                }
            }
        }
Пример #16
0
 public virtual void Visit(Gcode code)
 {
 }
Пример #17
0
        public Gcode FromXML(string filename, string path)
        {
            //log.Debug("In FromXML()");
            Gcode  clean    = null;
            bool   process  = false;
            string compiler = "";

            try
            {
                // Point to the file

                string fileLocation = System.IO.Path.Combine(path, filename);
                try
                {
                    FileStream fs = new FileStream(fileLocation, FileMode.Open, FileAccess.Read);

                    // Pass the parameters in

                    XmlReaderSettings xmlSettings = new XmlReaderSettings
                    {
                        // Enable <!ENTITY to be expanded
                        // <!ENTITY chap1 SYSTEM "chap1.xml">
                        // &chap1;

                        DtdProcessing = DtdProcessing.Parse
                    };

                    // Open the file and pass in the settings

                    try
                    {
                        Stack <string> stack   = new Stack <string>();
                        string         element = "";
                        string         text    = "";
                        string         current = ""; // Used to flag what level we are at
                        int            level   = 1;  // Indentation level

                        XmlReader xmlReader = XmlReader.Create(fs, xmlSettings);
                        while (xmlReader.Read())
                        {
                            switch (xmlReader.NodeType)
                            {
                                #region Element
                            case XmlNodeType.Element:
                            {
                                element = xmlReader.LocalName.ToLower();

                                if (!xmlReader.IsEmptyElement)
                                {
                                    //log.Info(Level(level) + "<" + element + ">");
                                    level = level + 1;
                                }
                                else
                                {
                                    //log.Info(Level(level) + "<" + element + "/>");
                                }
                                switch (element)
                                {
                                    #region Book
                                case "clean":
                                {
                                    stack.Push(current);
                                    current = element;
                                    clean   = new Gcode();
                                    break;
                                }

                                    #endregion
                                default:
                                {
                                    stack.Push(current);
                                    current = element;
                                    break;
                                }
                                }
                                break;
                            }

                                #endregion
                                #region EndElement
                            case XmlNodeType.EndElement:
                            {
                                element = xmlReader.LocalName;
                                level   = level - 1;
                                //log.Info(Level(level) + "</" + element + ">");
                                switch (element)
                                {
                                case "clean":
                                {
                                    break;
                                }
                                }
                                current = stack.Pop();
                                break;
                            }
                                #endregion
                                #region Text

                            case XmlNodeType.Text:
                            {
                                text = xmlReader.Value;
                                text = text.Replace("\t", "");
                                text = text.Replace("\n", "");
                                text = text.Trim();
                                //log.Info(Level(level) + text);

                                switch (current)
                                {
                                case "x":
                                {
                                    break;
                                }
                                }
                                break;
                            }

                                #endregion
                                #region Entity
                            case XmlNodeType.Entity:
                                break;

                                #endregion
                            case XmlNodeType.EndEntity:
                                break;

                            case XmlNodeType.Whitespace:
                                break;

                            case XmlNodeType.Comment:
                                break;

                            case XmlNodeType.Attribute:
                                break;

                            default:
                                //log.Info(xmlReader.NodeType);
                                break;
                            }
                        }

                        xmlReader.Close();  // Force the close
                        xmlReader = null;
                    }
                    catch (Exception ex)
                    {
                        //log.Warn("XML Error " + ex.Message);
                    }
                    fs.Close();
                    fs.Dispose();   // Force the dispose as it was getting left open
                }
                catch (FileNotFoundException ex)
                {
                    //log.Warn("File Error " + ex.Message);
                }
                catch (Exception ex)
                {
                    //log.Warn("File Error " + ex.Message);
                }
            }
            catch (Exception e)
            {
                //log.Error("Other Error " + e.Message);
            }

            //log.Debug("Out FromXML()");
            return(clean);
        }
        public async Task <List <LinesVisual3D> > Create2dGcodeLayerModelListAsync(Gcode gcode, IProgress <int> prog)
        {
            gcode.IsWorking = true;
            var list = new List <LinesVisual3D>();
            //var line = new LinesVisual3D();
            SortedDictionary <double, LinesVisual3D> gcodeLayers = new SortedDictionary <double, LinesVisual3D>();

            //ConcurrentBag<LinesVisual3D> layers = new ConcurrentBag<LinesVisual3D>();
            try
            {
                var Commands = gcode.Commands;
                await Task.Run(() =>
                {
                    try
                    {
                        var temp = new List <LinesVisual3D>();
                        int i    = 0;
                        //foreach (List<GCodeCommand> commands in Commands)
                        foreach (List <GcodeCommandLine> commands in Commands)
                        {
                            double z           = gcode.ZHeights.Keys.ElementAt(i);
                            var pointsPerLayer = GetLayerPointsCollection(commands, z);
                            if (pointsPerLayer.Count > 0)
                            {
                                Application.Current.Dispatcher.Invoke((() =>
                                {
                                    gcodeLayers.Add(z, new LinesVisual3D()
                                    {
                                        Points = new Point3DCollection(pointsPerLayer)
                                    });
                                    //layers.Add(new LinesVisual3D() { Points = new Point3DCollection(pointsPerLayer) });
                                }));
                            }
                            if (prog != null)
                            {
                                float test = (((float)i / Commands.Count) * 100f);
                                if (i < Commands.Count - 1)
                                {
                                    prog.Report(Convert.ToInt32(test));
                                }
                                else
                                {
                                    prog.Report(100);
                                }
                            }
                            i++;
                        }
                    }
                    catch (Exception exc)
                    {
                        logger.Error(string.Format(Strings.EventExceptionOccurredFormated, exc.TargetSite, exc.Message));
                    }
                });

                /**/
                Application.Current.Dispatcher.Invoke(() =>
                {
                    gcode.LayerModelGenerated = true;
                    list = gcodeLayers.Select(pair => pair.Value).ToList();
                });
                //list = layers.ToList();
            }
            catch (Exception exc)
            {
                logger.Error(string.Format(Strings.EventExceptionOccurredFormated, exc.TargetSite, exc.Message));
            }
            gcode.IsWorking = false;
            return(list);
        }

        public async Task <List <LinesVisual3D> > Create3dGcodeLayerModelListAsync(Gcode gcode, IProgress <int> prog)
        {
            gcode.IsWorking = true;
            var list = new List <LinesVisual3D>();

            SortedDictionary <double, LinesVisual3D> gcodeLayers = new SortedDictionary <double, LinesVisual3D>();

            try
            {
                var           Commands    = gcode.Commands;
                LinesVisual3D normalmoves = new LinesVisual3D();
                LinesVisual3D rapidmoves  = new LinesVisual3D();
                LinesVisual3D wirebox     = new LinesVisual3D();

                await Task.Run(() =>
                {
                    var temp = new List <LinesVisual3D>();
                    int i    = 0;

                    foreach (List <GcodeCommandLine> commands in Commands)
                    {
                        double z = gcode.ZHeights.Keys.ElementAt(i);
                        for (int j = 0; j < commands.Count; j++)
                        {
                            GcodeCommandLine cmd = commands[j];
                            if (cmd.Command != "g0" && cmd.Command != "g1" && cmd.Command != "g2" && cmd.Command != "g3")
                            {
                                continue;
                            }

                            double x_prev = !double.IsInfinity(cmd.PrevX) ? cmd.PrevX : 0;
                            double y_prev = !double.IsInfinity(cmd.PrevY) ? cmd.PrevY : 0;
                            double z_prev = !double.IsInfinity(cmd.PrevZ) ? cmd.PrevZ : 0;
                            double x      = !double.IsInfinity(cmd.X) ? cmd.X : x_prev;
                            double y      = !double.IsInfinity(cmd.Y) ? cmd.Y : y_prev;
                            //z = cmd.Z;

                            switch (cmd.Command)
                            {
                            case "g0":
                                Application.Current.Dispatcher.Invoke((() =>
                                {
                                    DrawLine(rapidmoves, x_prev, y_prev, z_prev, x, y, z);
                                }));
                                break;

                            case "g1":
                                Application.Current.Dispatcher.Invoke((() =>
                                {
                                    DrawLine(normalmoves, x_prev, y_prev, z_prev, x, y, z);
                                }));
                                break;

                            case "g2":
                            case "g3":
                                /*
                                 * bool clockwise = false;
                                 * if (cmd.Command == "g2")
                                 *  clockwise = true;
                                 */
                                throw new Exception("Not supported!");
                            }

                            x_prev = x;
                            y_prev = y;
                            z_prev = z;
                        }