G代码简单解释

公司的切割机用的是梅塞尔的等离子切割机，技术部在下发套料图的时候，会将指令文件做简化处理，形式如下：

%
N4G92X0Y0
N6F5000
N8G71
N10G91
N12G00X561.243Y1277.726
N14M11
N16M09
N18G01X75.071Y160.966
N20G01X-44.119Y75.746
N22G01X86.386Y14.882
N24G01X75.071Y160.966
N26M10
N28G00X53.516Y-0.015
N30M09
N32G01X-75.071Y-160.966
N34G01X44.119Y-75.746
N36G01X-86.386Y-14.882
N38G01X-75.071Y-160.966
N40M10
N42G00X15.005Y495.332
N44M09
N46G01X94.148Y237.483
N48G01X-48.505Y73.015
N50G01X85.359Y19.946

N168G03X2.562Y9.562I-3.5J6.062

　查了一下手册，%表示指令文件开始；N指令表示行号，但是我没弄明白为什么行号都是偶数；G命令表示切割与定位。XYIJ表示坐标命令，XY为相对相对坐标增量，IJ表示圆心（由于我公司加工的钢板零件都是直线和圆弧形式，且切割点都为相对增量模式，所以其他命令暂时没有研究）

　　以N168G03X2.562Y9.562I-3.5J6.062 这句指令为例：N168，表示是第168个指令行，对切割机无实际作用，可忽略；G03，表示以顺时针方向切割圆弧，起始点为上一命令的切割点，终止点为此命令行的坐标点，即为X2.562Y9.562，圆心为I-3.5J6.062。注意：坐标值皆以上一命令点为基准作增量运算。

　　命令代码绝大多数为 G00(走空直线，即切割嘴不点火定位)、G01(切割直线，即切割嘴点火切割定位)、G02/G03(切割圆弧，G02为顺时针切割，G03为逆时针切割)

　　I和J为圆心坐标。

下面用C#解析G代码文件：

　　1. 先把指令文件中与切割无关的命令过滤掉，生成一个临时的指令文件：

public static string GenFile(string filename)
        {
            StreamReader r_sReader = new StreamReader(filename);
            StreamWriter w_sWriter = new StreamWriter(filename + ".tmp");

            string r_Line = string.Empty;
            int g_index = -1;
            r_Line = r_sReader.ReadLine();
            if (r_Line != "%")
            {
                r_sReader.Close();
                w_sWriter.Close();
                throw new Exception("命令: " + filename + " 的格式不在本程序处理范围内，请联系软件开发人员！");
            }
            for (; r_Line != null; r_Line = r_sReader.ReadLine())
            {
                if (Lex.FindKey(r_Line, "G0") && Lex.FindKey(r_Line, 'X'))
                {
                    g_index = r_Line.IndexOf("G0");
                    r_Line = r_Line.Substring(g_index);
                    w_sWriter.WriteLine(r_Line);
                }
            }
            r_sReader.Close();
            w_sWriter.Close();
            return filename + ".tmp";
        }

生成的临时指令文件类似于：

G01X-733.139Y129.272
G01X-61.743Y-62.224
G01X-36.738Y79.589

G03X7.0Y7.0I0.0J7.0
G01X0.0Y534.0
G03X35.0Y35.0I0.0J35.0
G01X185.0Y0.0

这样看起来就清晰多了。只需要处理G命令和相应的坐标了：

public static void CalculateLength(string filename, out double CuttingLength, out Double WalkLength, out int FireTimes)
        {
            CuttingLength = 0.0;
            WalkLength = 0.0;
            FireTimes = 0;

            Point2D p_start = new Point2D(0.0, 0.0);
            Point2D p_end = new Point2D(0.0, 0.0);
            Point2D p_center = new Point2D(0.0, 0.0);

            Arc2D tmp_arc = new Arc2D(p_center, p_start, p_end);
            LineSegment2D tmp_seg = new LineSegment2D(p_start, p_end);
            StreamReader r_sReader = new StreamReader(filename);
            // read line.
            string r_Line = string.Empty;
            // instruction appearing in current line.
            string instruction = string.Empty;
            #region Relative Coordinate
            Point2D p_current = new Point2D();
            for (int i=0; r_Line != null; r_Line = r_sReader.ReadLine(), i++)
            {
                if (r_Line == string.Empty)
                    continue;

                instruction = GetAxisValue(r_Line, 'G');
                p_current.X = Convert.ToDouble(GetAxisValue(r_Line, 'X'));
                p_current.Y = Convert.ToDouble(GetAxisValue(r_Line, 'Y'));

                switch (instruction)
                {
                    case "00":
                        tmp_seg.EndPt.X = p_current.X;
                        tmp_seg.EndPt.Y = p_current.Y;
                        WalkLength += tmp_seg.Length;
                        FireTimes++;
                        break;
                    case "01":
                        tmp_seg.EndPt.X = p_current.X;
                        tmp_seg.EndPt.Y = p_current.Y;
                        CuttingLength += tmp_seg.Length;
                        break;
                    case "02":
                        tmp_arc.CenterPt.X = Convert.ToDouble(GetAxisValue(r_Line, 'I'));
                        tmp_arc.CenterPt.Y = Convert.ToDouble(GetAxisValue(r_Line, 'J'));
                        tmp_arc.EndPt.X = p_current.X;
                        tmp_arc.EndPt.Y = p_current.Y;
                        CuttingLength += tmp_arc.ClockWiseLength;
                        break;
                    case "03":
                        tmp_arc.CenterPt.X = Convert.ToDouble(GetAxisValue(r_Line, 'I'));
                        tmp_arc.CenterPt.Y = Convert.ToDouble(GetAxisValue(r_Line, 'J'));
                        tmp_arc.EndPt.X = p_current.X;
                        tmp_arc.EndPt.Y = p_current.Y;
                        CuttingLength += tmp_arc.CounterClockWiseLength;
                        break;
                }
            }
            #endregion
            r_sReader.Close();
        }

上面的代码有我自定义的几个类，用于计算线段长度和圆弧长度：

public static class m_Math
    {
        public const Double Pi = 3.1415926535;
        public const Double E = 2.7182818284;
        public const Double _precision = 0.00001;

        public static Double sqrt(Double n)
        {
            double result = 0.0, delta = 0.0;
            double x = 0.618 * n;
            do
            {
                result = 0.5 * (x + (n / x));
                delta = Math.Abs(x - result);
                x = result;
            } while (delta > m_Math._precision);
            return result;
        }

        public static Double RadianToAngle(Double radian)
        {
            return (180.0 * radian) / m_Math.Pi;
        }

        public static Double AngleToRadian(Double angle)
        {
            return (m_Math.Pi * angle) / 180.0;
        }

        public static double[,] MatrixProduction(double[,] a, double[,] b)
        {
            int Length=a.Length;
            double[,] c=new double[Length,Length];
            return c;
        }
    }

    public class Point2D
    {
        public Point2D() { }
        public Point2D(Double x,Double y)
        {
            this.X = x;
            this.Y = y;
        }

        /// <summary>
        /// X coordinate figure
        /// </summary>
        private Double _X;

        /// <summary>
        /// Y coordinate figure
        /// </summary>
        private Double _Y;

        public Double X
        {
            get
            {
                return this._X;
            }

            set
            {
                this._X = value;
            }
        }

        public Double Y
        {
            get
            {
                return this._Y;
            }

            set
            {
                this._Y = value;
            }
        }

        public Double GetDistanceTo(Point2D p)
        {
            Double dx = this.X - p.X;
            Double dy = this.Y - p.Y;
            return Math.Sqrt(dx * dx + dy * dy);
        }

        public Vector2D GetVector2DTo(Point2D p)
        {
            return new Vector2D(p.X - this.X, p.Y - this.Y);
        }

        public void SetValueTo(Point2D p)
        {
            this.X = p.X;
            this.Y = p.Y;
        }

        public bool IsEqualTo(Point2D p)
        {
            return (this.X == p.X && this.Y == p.Y);
        }

        public bool IsOnSeg(LineSegment2D seg)
        {
            if (this.IsOnSegLine(seg))
            {
                return (this.X <= Math.Max(seg.StartPt.X, seg.EndPt.X)) && (this.X >= Math.Min(seg.StartPt.X, seg.EndPt.X));
            }

            return false;
        }

        public bool IsOnSegLine(LineSegment2D seg)
        {
            Vector2D vseg = seg.StartPt.GetVector2DTo(seg.EndPt);
            Vector2D vthis = seg.StartPt.GetVector2DTo(this);
            return Math.Abs(vseg.CrossProductTo(vthis)) < m_Math._precision;
        }

        public static Point2D operator + (Point2D a, Point2D b)
        {
            return new Point2D((a.X + b.X), (a.Y + b.Y));
        }

        public static Point2D operator - (Point2D a, Point2D b)
        {
            return new Point2D((a.X - b.X), (a.Y - b.Y));
        }

        public override String ToString()
        {
            return "(" + this.X + "," + this.Y + ")";
        }
    }

    public class LineSegment2D
    {
        public LineSegment2D()
        {
            this.StartPt = new Point2D();
            this.EndPt = new Point2D();

        }
        public LineSegment2D(Point2D p1, Point2D p2)
        {
            this.StartPt = new Point2D();
            this.EndPt = new Point2D();
            this.StartPt.SetValueTo(p1);
            this.EndPt.SetValueTo(p2);
        }

        private Point2D _StartPt;
        private Point2D _EndPt;

        public Point2D StartPt
        {
            get
            {
                return this._StartPt;
            }

            set
            {
                this._StartPt = value;
            }
        }

        public Point2D EndPt
        {
            get
            {
                return this._EndPt;
            }

            set
            {
                this._EndPt = value;
            }
        }

        public Double Length
        {
            get
            {
                return StartPt.GetDistanceTo(EndPt);
            }
        }

        public void SetPt(Point2D p1, Point2D p2)
        {
            this.StartPt.X = p1.X;
            this.StartPt.Y = p1.Y;
            this.EndPt.X = p2.X;
            this.EndPt.Y = p2.Y;
        }

        public bool IsIntersectionWith(LineSegment2D seg)
        {
            Vector2D s1s2 = this.StartPt.GetVector2DTo(seg.StartPt);
            Vector2D s1e2 = this.StartPt.GetVector2DTo(seg.EndPt);
            Vector2D s1e1 = this.StartPt.GetVector2DTo(this.EndPt);
            double straddle1 = (s1e1.CrossProductTo(s1s2)) * (s1e1.CrossProductTo(s1e2));
            Vector2D s2s1 = seg.StartPt.GetVector2DTo(this.StartPt);
            Vector2D s2e1 = seg.StartPt.GetVector2DTo(this.EndPt);
            Vector2D s2e2 = seg.StartPt.GetVector2DTo(seg.EndPt);
            double straddle2 = (s2e2.CrossProductTo(s2s1)) * (s2e2.CrossProductTo(s2e1));

            if (straddle1 < 0 && straddle2 < 0)
            {
                return true;
            }
            else 
            {
                return (this.StartPt.IsOnSeg(seg) || this.EndPt.IsOnSeg(seg) || seg.StartPt.IsOnSeg(this) || seg.EndPt.IsOnSeg(this));
            }
        }
    }

    public class Vector2D
    {
        public Vector2D() { }
        public Vector2D(Double x, Double y)
        {
            this.X = x;
            this.Y = y;
        }
        /// <summary>
        /// X coordinate figure
        /// </summary>
        private Double _X;
        /// <summary>
        /// Y coordinate figure
        /// </summary>
        private Double _Y;

        public Double X
        {
            get
            {
                return this._X;
            }

            set
            {
                this._X = value;
            }
        }

        public Double Y
        {
            get
            {
                return this._Y;
            }

            set
            {
                this._Y = value;
            }
        }

        public Double Length
        {
            get
            {
                return Math.Sqrt(this.X * this.X + this.Y * this.Y);
            }
        }

        public Double StartAngle
        {
            get
            {
                Double angle = Math.Acos(this.X / this.Length);
                if (this.Y<0)
                {
                    return 2 * m_Math.Pi - angle;
                }
                return angle;
            }
        }

        /// <summary>
        /// Counter clock wise Cross-Production to Vector2D(v)
        /// as the two vectors are both on X-Y plane, their Cross-Production is on Z-Axis
        /// </summary>
        public Double CrossProductTo(Vector2D v)
        {
            return (this.X * v.Y - this.Y * v.X);
        }

        public Double GetNormalAngleTo(Vector2D v)
        {
            Double DotProduction = this * v;
            // may be "projection" is 1.00000000002 or some other, in this case, the Math.Acos() method will return NaN(Not a Number).
            // so if |projection| > 1 and | |projection| - 1 |< _precision, must set it to 1.
            Double projection = (DotProduction) / (this.Length * v.Length);
            if (Math.Abs(projection) > 1)
            {
                double delta = Math.Abs(Math.Abs(projection) - 1);
                if (delta < m_Math._precision)
                {
                    if (projection > 1)
                    {
                        projection = 1;
                    }
                    else if (projection < -1)
                    {
                        projection = -1;
                    }
                }
            }
            return Math.Acos(projection);
        }

        public bool IsSameDirectionTo(Vector2D v)
        {
            Double DeltaAngle = Math.Abs(v.StartAngle-this.StartAngle) ;
            return DeltaAngle > 0 && DeltaAngle < m_Math._precision;
        }

        public bool IsOppositeDirectionTo(Vector2D v)
        {
            Double DeltaAngle = Math.Abs(Math.Abs(v.StartAngle - this.StartAngle)-m_Math.Pi);
            return DeltaAngle > 0 && DeltaAngle < m_Math._precision;
        }

        public bool IsClockWiseTo(Vector2D v)
        {
            return this.CrossProductTo(v) < 0;
        }

        public bool IsCounterClockWiseTo(Vector2D v)
        {
            return this.CrossProductTo(v) > 0;
        }

        public Double GetCounterClockWiseAngleTo(Vector2D v)
        {
            Double Angle = this.GetNormalAngleTo(v);
            if (this.IsClockWiseTo(v))
            {
                return 2 * m_Math.Pi - Angle;
            }
            return Angle;
        }

        public override String ToString()
        {
            return "(" + this.X + "," + this.Y + ")";
        }

        public static Vector2D operator + (Vector2D a, Vector2D b)
        {
            return new Vector2D((a.X + b.X), (a.Y + b.Y));
        }

        public static Vector2D operator - (Vector2D a, Vector2D b)
        {
            return new Vector2D((a.X - b.X), (a.Y - b.Y));
        }

        public static Double operator * (Vector2D a, Vector2D b)
        {
            return (a.X * b.X + a.Y * b.Y);
        }
    }

    public class Arc2D
    {
        public Arc2D()
        {
            this.CenterPt = new Point2D();
            this.StartPt = new Point2D();
            this.EndPt = new Point2D();
        }

        public Arc2D(Point2D center, Point2D start, Point2D end)
        {
            if (Math.Abs(center.GetDistanceTo(start) - center.GetDistanceTo(end)) > m_Math._precision)
            {
                //throw new Exception("Radius length is not equal!");
                throw new Exception("半径长度不相等, 不能构成圆！");
            }

            this.CenterPt = new Point2D();
            this.StartPt = new Point2D();
            this.EndPt = new Point2D();

            this.CenterPt.SetValueTo(center);
            this.StartPt.SetValueTo(start);
            this.EndPt.SetValueTo(end);
        }

        private Point2D _CenterPt;
        private Point2D _StartPt;
        private Point2D _EndPt;

        public Point2D CenterPt
        {
            get
            {
                return this._CenterPt;
            }

            set
            {
                this._CenterPt = value;
            }
        }

        public Point2D StartPt
        {
            get
            {
                return this._StartPt;
            }

            set
            {
                this._StartPt = value;
            }
        }

        public Point2D EndPt
        {
            get
            {
                return this._EndPt;
            }

            set
            {
                this._EndPt = value;
            }
        }

        public Vector2D StartRadius
        {
            get
            {
                return this.CenterPt.GetVector2DTo(this.StartPt);
            }
        }

        public Vector2D EndRadius
        {
            get
            {
                return this.CenterPt.GetVector2DTo(this.EndPt);
            }
        }

        public Double RadiusLength
        {
            get
            {
                return this.StartRadius.Length;
            }
        }

        public Double StartAngle
        {
            get
            {
                return this.StartRadius.StartAngle;
            }
        }

        public Double EndAngle
        {
            get
            {
                return this.EndRadius.StartAngle;
            }
        }

        /// <summary>
        /// Angle is from StartAngle to EndAngle in Counter-Clock-Wise
        /// </summary>
        public Double Angle
        {
            get
            {
                Double angle = this.StartRadius.GetCounterClockWiseAngleTo(this.EndRadius);
                return angle;
            }
        }

        public Double Bulge
        {
            get
            {
                return Math.Tan((this.EndAngle - this.StartAngle) / 4.0);
            }
        }

        public Double CounterClockWiseLength
        {
            get
            {
                return this.StartRadius.Length * this.Angle;
            }
        }

        public Double ClockWiseLength
        {
            get
            {
                return 2 * m_Math.Pi * this.StartRadius.Length - this.CounterClockWiseLength;
            }
        }

        public Double CounterClockWiseArea
        {
            get
            {
                return RadiusLength * RadiusLength * this.Angle;
            }
        }

        public Double ClockWisePatchArea
        {
            get
            {
                return 2 * m_Math.Pi * this.RadiusLength * this.RadiusLength - this.CounterClockWiseArea;
            }
        }
    }

Point2D 是二维点类，方便计算线段长度；LineSegment2D是线段类，没有方向，只用于计算长度；

Vector2D二维向量类，用于计算圆弧的圆心角；Arc2D圆弧类，用于计算顺时针与逆时针的圆弧长度。

还有两个方法：

用于检验是否是数字：

public static bool IsDigit(char ch)
        {
            return (ch >= '0' && ch <= '9');
        }

用于获取指令值与坐标值：

public static string GetAxisValue(string inLine, char AxisSymbol)
        {
            string Line = Lex.TrimAllSpace(inLine);
            int pos = Line.IndexOf(AxisSymbol);
            if (pos == -1)
            {
                // if the current line has no AxisSymbol, then it contains no this AxisSymbol value at all.
                return string.Empty;
            }

            //scan the current line until it meets a char that is not a digit.
            bool DecimalPointFound = false;
            string m_value = string.Empty;
            for (int i = pos + 1; i < Line.Length; i++)
            {
                if (Lex.IsDigit(Line[i]))
                {
                    m_value += Line[i];
                }
                // check whether the '-' is a negative sign or not.
                else if (Line[i] == '-')
                {
                    if (i < Line.Length - 1)
                    {
                        if ((Line[i - 1] == AxisSymbol) && Lex.IsDigit(Line[i + 1]))
                        {
                            m_value += Line[i];
                        }
                    }
                }
                // if the current char is a dot('.') , and both its previous and latter char are digit,
                // then it is a decimal point.
                else if (Line[i] == '.')
                {
                    if (i < Line.Length - 1)
                    {
                        if (Lex.IsDigit(Line[i - 1]) && Lex.IsDigit(Line[i + 1]))
                        {
                            if (DecimalPointFound)
                            {
                                // if Decimal Point is Found previously, 
                                // then the digits set found is not a digit string(e.g. : 2011.04.17).
                                // that is, decimal point only appear once.
                                return string.Empty;
                            }
                            DecimalPointFound = true;
                            m_value += Line[i];
                        }
                        else if (Lex.IsAlpha(Line[i]))
                        {
                            return string.Empty;
                        }
                    }
                }
                else
                {
                    // if the current char is not a digit, then the left ones are not necessary to be scanned.
                    break;
                }
            }
            return m_value;
        }

程序还有好多漏洞，待完善。