Advanced Path Interpolation in High Performance ...

Proceedings of the 8th World Congress on Intelligent Control and Automation July 6-9 2010, Jinan, China

Advanced Path Interpolation in High Performance Motion Control Systems∗ Dongjun Zhang

Zexiang Li

Shuang Cong

Hong Wu

PKU-HKUST Shenzhen-Hong Kong Institute. Dept. ECE, HKUST. Dept. Automation, USTC. Googol Tech. (SZ) Ltd. [email protected] [email protected] [email protected] [email protected]

Abstract—In the path following motion control system, the reference tool path of the machine tool is geometric curves predetermined by applications. The reference motion command for servo control system is generated based on the geometric tool path and the feedrate. The command generation module is called path interpolation. It is a classical problem in the motion control system. However, a clear formula is still missing in the literature. In this paper, path interpolation problem for the generic parametric tool path is formulated clearly in a mathematical way. By examining the parametrization of the tool path, the problem turns out to be an initial value problem for the ordinary differential equation system (ODE). From this formula, traditional interpolation algorithms, like digital differential analyzer (DDA) and digital increment algorithm, are easily derived. Numerical computation algorithms, such as the truncated Taylor expansion algorithm, the Runge-Kutta algorithm and the predictor-corrector algorithm, can be utilized. Considering reliability, accuracy and complexity, all those algorithms are analyzed and compared from three perspectives theoretical comparison based on numerical analysis, simulation and experiments. Although the Taylor expansion algorithms and the predictor-corrector algorithms are widely used in the literature, the Runge-Kutta algorithms are highly recommended from our analysis and comparison. The Runge-Kutta algorithm of order 4 is recommended, if the computation resource is available. Index Terms—Path following motion control system, Path interpolation, Chord error, Local and global discretization error.

I. I NTRODUCTION

H

IGH performance motion control systems are widely demanded from industry, for example, flying cutting of metal sheets, milling, lathing and semiconductor packaging, etc. All of them require high speed feeding for high productivity and high accurate tracking for high quality. There are three types of motion in industry. The first motion type is called synchronization motion where position or velocity command of the servo is determined by online measurement. The second motion type is called point-to-point motion where the reference of the machining tool is a sequence of positions to be reached accurately and fast. The third motion type is path following motion where the desired geometric tool path ∗ This work is supported by RGC Grant #616606 and G9108, and by NSFC grants #50505009 and #50535010

978-1-4244-6712-9/10/$26.00 ©2010 IEEE

is designed in advance. To achieve the speed and accuracy requirements, the motion command need to be generated properly. Then the machine tool, driven by the mechatronic system, travels along the prescribed tool path. Classical motion control system can handle lines and circular arcs. The algorithms are described in the book [1]. These can also be found in [2]. Especially, the DDA algorithm is widely used in industry. The drawbacks of these approaches are: • The computer aided manufacturing (CAM) system has to approximate a smooth tool path by lines and circular arcs. Obviously, this approximation will introduce errors; • To control the approximation errors, the numbers of tool path segments will increase. Thus more storage space is required. As a result, the load of transmission channel will increase too; • The generated tool path is not smooth. Acceleration or deceleration on each segment is needed in order to avoid mechanical vibration or tracking accuracy degradation. Thus the total machining time will increase too. Traditional interpolation algorithms can not fulfill modern manufacturing requirements, especially for high speed and high precision applications. To improve the system performance, the geometrical shape of machining parts, the tolerance specifications and the tool paths should be represented in an effective way. Then effective interpolation algorithms can be designed for motion command generation. If the computer aided design (CAD) softwares can provide parametric tool path, the motion control system needs novel algorithms for interpolating free form curves. Suppose the tool path is piecewise smooth and is represented in parametric form. The parameter of tool path is chosen artificially by the CAD softwares. To generate motion command periodically, the parameter should be time t. Thus an allowable reparametrization from geometric parameter to time needs to be found. In the literature, Chou and Yang [3] first aimed to develop a general theory of command generation for multi-axis machines. Unfortunately there are some errors in their solution, and the feedrate scheduling is not considered. Huang and Yang [4], Shpitalni et al. [5] proposed a parametric

2925

interpolator to generate motion commands. Yeh and Hsu [6] improved their algorithm with an adaptive feedate adjustment to achieve accuracy requirements. To obtain smooth feedrate, many algorithms [7], [8], [9] have been proposed. Look ahead techniques are used in [10], [11]. Cheng et al. [12] proposed a predictor-corrector method to update the parameter. Yong and Narayamaswami [13] reduced speed fluctuation further by detecting the discontinuous points of tool path. Yang and Kong [14] presented a comparative study of linear and parametric interpolators for precision machining. Their comparison included memory size, feedrate fluctuation, CPU time, tracking errors and jerk magnitude. The investigation showed that the parametric interpolator possesses many advantages in machining free form surface. However, the computation complexity of the algorithms limits the real time implementation. Recently, Lei et al. [15], [16] proposed an inverse length function to interpolate non-uniform rational Bspline (NURBS) curves. By utilizing the numerical integration algorithms in the preprocess procedure, the algorithms can be implemented in real time applications. Although some algorithms are provided in the literature, the problem formula had never been stated clearly. All the authors planned to solve the path interpolation and feedrate scheduling problem in one step. It is a reasonable choice, since the feedrate will affect the interpolation accuracy in general, but it can be separated by using look-ahead technique in the preprocess procedure. The tool path is cut into pieces where each piece has the same geometric and process feature. Then feedrate profile can be designed on each segment. By using this two-steps strategy, the path interpolation problem can be formulated as an initial valued problem for the ODE system. From this formula, DDA algorithm can be easily derived, if the arc length of tool path can be computed analytically. It is obvious that all numerical algorithms can be utilized. Stability, complexity and accuracy are investigated to measure the performance of the interpolation algorithms. Especially, how local and global discretization error of numerical algorithms affect the path interpolation accuracy is analyzed. The truncated Taylor expansion algorithms, the Runge-Kutta algorithms and the predictor-corrector algorithms are provided and compared by theoretical analysis and experimental verification. The paper is organized as follows. In section II, path interpolation problem is formulated as an initial value problem for the ODE system. In section III, various numerical algorithms are provided, the performance is investigated based on the numerical analysis. In section IV, simulation and experimental results are shown to compare the interpolation algorithms. Finally the conclusion is given, and future works are stated. II. I NTERPOLATION PROBLEM In the paper, let us assume that:

The tool path is piecewise differentiable at least twice; The tool path is given in a parametric form, denoted by P (u) ∈ R3 , where u ∈ [0, 1] is the normalized parameter, R = (−∞, +∞); 1 • The dynamic speed of the tool path is known and C differentiable. Notice that the parameter is chosen artificially, it may not coincide with the arc length or time. Now let us define some basic concepts. The tool path generated by the CAM system is geometric. It is called dynamic after the feedrate is designed. The dummy variable u can be treated as a function of time t. This function links the geometric and dynamic tool path by the composition of the map. • •

Definition II.1 Link function The link function is the monotonic increasing function from the dummy parameter u to time t. It is the following function u : R+ → R+ t : → u(t)

where

du dt

(1)

≥ 0.

From the chain rule, we have the following formula, vd (t) = 

dP (u) du dP (t) du =  = vg (u(t)) dt du dt dt

(2)

vd (t) Thus du dt = vg (u)  f (t, u). In the motion control system, based on the geometric tool path P (u), the tolerance specification and the dynamic constraints of mechatronic system, the motion command is generated periodically as the reference signals for servo motors. Intuitively, the motion control system discretizes the tool path and obtains the position command periodically. However, arbitrary discretization algorithm will generate large feedrate fluctuation. The interpolation algorithms should generate motion command where the feedrate profile coincides with the given feedrate profile. For parametric curves, instead of discretizing tool path directly, it is much better to compute the parameter uk = u(tk = kT ) first, then generate the position command Pk = P (uk ). T is the interpolation cycle time. That means the interpolation algorithms need to find the link function u(t) and reparameterize the geometric tool path into the dynamic tool path. In practice, only the values at time [0, T, 2T, · · · , N T ] are required for the function u(t) and the position P (u). The geometric velocity of the tool path vg (u) =  dPdu(u)  can be computed from the geometric tool path representation, but the dynamic speed of the tool path vd (t) is free to be specified. The algorithm to generate the dynamic speed of the tool path is called feedrate scheduling algorithm. The geometric constraints and the dynamic constraints are all needed to be considered in the algorithm. Usually the

2926

maximal feedrate and the maximal acceleration, denoted by F and A respectively, are specified by look ahead techniques and users depending on applications. By integrating the feedrate along the tool path, the arc length of the tool path is obtained. At the end point of the tool path, we have  1  tf vd (t)dt = L = vg (u)du (3) 0

0

for some tf = N T . The Equ.(3) imposed a final value boundary condition on the dynamic speed of the tool path vd (t). In practice, there are two types of feedrate profiles. They are called T type and S type profile. It has been proved in [17] that the T type profile is time optimal profile with maximal feedrate limitation, and the S type profile is time optimal profile with maximal feedrate and acceleration limitation. The feedrate scheduling algorithms will be investigated further in another paper. Recall the assumptions, the interpolation problem is formulated as follows. Problem II.1 Given the geometric tool path P (u) and the dynamic speed of the tool path vd (t), the interpolation algorithms need to solve the following initial valued problem for the ODE system at periodical time [0, T, · · · , N T ], ⎧ ⎪ ⎨ du = f (t, u) = vd (t) = vd (t) dt vg (u)  dPdu(u)  (4) ⎪ ⎩ u(0) = 0

Then compute the position command Pk = P (u(kT )). Remark II.1 If the geometric variable coincides with the arc length, the problem becomes much simpler, ⎧ ⎨ du = ds = f (t, s) = v (t) d (5) dt dt ⎩ u(0) = 0

The equation can be solved by the Riemann sum formula directly. Classical interpolation algorithms, like DDA and digital increment algorithm [1], are based on this formula, i.e., sk = sk−1 + vd (tk ), vd (tk ) = vd (tk−1 ) +

dvd dt |t=tk−1 .

u(t), find the function u(s) by solving the following ODE system ⎧ ⎨ du = 1 ds vg (u) (7) ⎩ u(0) = 0

This algorithm is called the interpolation before the feedrate scheduling. The algorithm computes the parameter uk = u(sk ) where sk = {0, Δ, · · · , N Δ}, then computes the Pk = P (uk ). Notice that u(N Δ) = 1, so N Δ = position 1 v (u)du = L. The algorithm to generate smooth position 0 g command further based on the position Pk and feedrate vd (tk ) is called fine interpolation algorithm. Our framework can solve both cases in a unified way, the only difference is that the ODE function becomes f (u, s) = 1 vg (u) for the later case. The algorithms [15], [16] fall into this category. The quadrature formula is used for numerical integration, then curve fitting methods are used for real time implementation. The accuracy of the interpolation algorithm can be measured by two types of errors. The first one is the numerical error for computing the parameter uk . This will be discussed later. The second one is the chord error and the dynamic speed error. Although the discretized position is located exactly on the geometric tool path, the intermediate position information is unknown to mechatronic system. If using the straight line segment to approximate the arc between two sequential points, the interpolation accuracy can be measured by following errors. Definition II.2 The chord error at step k is the maximal error between the line Pk−1 Pk and the arc segment, i.e. δc (k) = max du  u∈[uk−1 ,uk ] Pk −Pk−1 >2 du = P (u) − Pk−1 2 − < P (u) − Pk−1 , P k −Pk−1  (8) is the distance between the point P (u) and the line Pk−1 Pk . Definition II.3 The dynamic speed error at step k is the error between the generated reference speed at time tk and the dynamic speed at point Pk−1 . It is measured by the magnitude error and the angle error, i.e. vd (tk ) − Pk − Pk−1 /T , vd (tk ) < Vd (tk ), Pk − Pk−1 > δθ (k) = cos−1 . vd (tk ) · Pk − Pk−1 

δv (k) =

(6)

For generic parametric tool path, the arc length usually is hard to be represented in explicit form. This is the major reason why more effort should be put on the parametric tool path. Remark II.2 Another way of interpolation is to discretize the tool path with equal arc length, then generate the position command based on the scheduled feedrate, i.e., instead of

(9)

Remark II.3 Even if the exact solution of path interpolation is obtained, these errors may be nonzero because of the curvature of the tool path. These errors are also related to the interpolation cycle and the feedrate. The numerical computation will cause feedrate fluctuation because of quantization

2927

and discretization error. This will be discussed in the next section.

where uk is the exact solution of the ODE problem at time tk . The global discretization error at step k + 1 is defined as eG (k) = uk+1 − u ˆk − T Φ(tk+1−i , u ˆk+1−j , fk+1−i ; T ) ˆk+1 = uk+1 − u (15)

III. A LGORITHMS FOR THE INTERPOLATION PROBLEM In summary, the interpolation problem needs to solve the initial valued problem for the ODE system to update the parameter, then computes the motion command from the geometric tool path. Based on the following theorem [18], [19], [20], [21], the problem is well posed, the global solution exists and is unique under our assumptions. Theorem III.1 Suppose the function defined from domain Ω to the real line R f :Ω→R du = f (t, u) (t, u) → dt

(10)

is continuous and locally Lipschitz continuous with respect to the state variable u, and (t0 , u0 ) ∈ Ω, then there exists an unique solution of the initial valued problem for this ODE system. The solution u(t; u0 ) is continuous up to the boundary of the space Ω and continuous with respect to the initial value u0 . The simple algorithm is the Taylor expansion method. The formula can be written as T p df p−1 (tk , u ˆk ) +O(T p+1 ) p−1 p! dt (11) where u ˆk is the computed function value at step tk , and O(T p+1 ) is the reminder of the high order terms. The algorithm is a one step method since only one memory is required for the previous results u ˆk . The algorithm is explicit ˆk+1 ) is not required. because f (tk+1 , u In general the solution of the initial value problem for the ODE system can be written as ˆk +T f (tk , u ˆk )+· · ·+ u ˆk+1 = u

ˆk + T Φ(tk+1−i , u ˆk+1−j , fk+1−i ; T ) u ˆk+1 = u

(12)

The algorithm is called q step method if j ∈ [1, · · · , q]. The method is implicit if i ∈ [0, 1, · · · , r], and it is explicit if i ∈ [1, · · · , r]. The method is called linear if the function Φ(·) depends on the variables linearly, otherwise it is called nonlinear. The linear method can be written as ˆk + u ˆk+1 = u

q−1 j=1

aj u ˆk−j + T

r−1

bj fk−j

The numerical method is called of order p if the global discretization error satisfy max{eG (k)} = O(T p ) k

Remark III.1 The local discretization error measures the approximation error at time tk+1 provided the exact solution of previous steps is known. The global discretization error measures the approximation error at time tk+1 provided the solution of the previous steps is estimated from Equ.12. Remark III.2 It has been recognized that [15] the local discretization error will cause feedrate fluctuation, and the global discretization error will cause feedrate jump at the end of the curve segments. But this effect of the global discretization error can be avoided by using numerical integration algorithms in the preprocess procedure. By quadrature formula, the arc length can be computed satisfying the tolerance requirements, then an inverse length function is obtained by curve fitting algorithms. The Taylor expansion algorithm is of order p provided the ODE function is continuous differentiable of order p, i.e. f ∈ C p (Ω, R). It needs to compute the p−1 order derivatives of the ODE function f . Remark III.3 It is well know in system theory that differentiation will amplify noises. In numerical computation algorithms, all numbers have only finite precision. This quantization error will become the source of noise when high derivatives are computed. It is also time consuming in some cases. For example, the NURBS curve is defined recursively and the computation for derivatives is very time consuming. There are many algorithms to avoid this computation. For example, the Runge-Kutta algorithm. The explicit one step Runge-Kutta method has the following formula, ˆk + T u ˆk+1 = u

(13)

m

aj gj (tk,j , u ˆk,j , T )

j=1

j=−1

Definition III.1 The local discretization error of the numerical method at step k + 1 is defined as eL (k) = uk+1 − uk − T Φ(tk+1−i , uk+1−j , fk+1−i ; T ) (14)

(16)

gj (tk,j , uk,j , T ) = f (tk + cj T, uk + T

j−1

s=1

bjs gs (tk,s , uk,s , T ))

(17) The Runge-Kutta method is of order m for m ≤ 4 provided f ∈ C m (Ω, R). The method needs to compute the ODE function m times.

2928

Remark III.5 Although the corrector can reduce the approximation error, the error can not be arbitrary small. The reasons are that • Both the predictor and the corrector have local and global discretization error; • There are quantization errors in numerical algorithms; • The solution of the ODE system for path interpolation is not a polynomial function in general. Because of time constraints, the iterative algorithms are not recommend in real time applications.

Table 1. The experimental results Runge-Kutta 1st Runge-Kutta 2nd RM S(δc ) 1.359593 ×10−6 3.847065 ×10−6 M AX(δc ) 0.006325362 0.021326484 RM S(δv ) 2.086549 ×10−5 7.548024 ×10−6 M AX(δv ) 0.125741728 0.041327407 RM S(δθ ) 4.658290 ×10−5 5.494566 ×10−5 M AX(δθ ) 0.088498134 0.095072159 RM S(δt ) 0.003790058 0.004702089 M AX(δt ) 2.576865678 2.641026544 Runge-Kutta 3rd I Runge-Kutta 3rd II RM S(δc ) 1.637677 ×10−6 4.081324 ×10−6 M AX(δc ) 0.006175703 0.022733692 RM S(δv ) 7.057619 ×10−6 6.62038 ×10−6 M AX(δv ) 0.030987658 0.036839183 RM S(δθ ) 5.424065 ×10−5 5.461757 ×10−5 M AX(δθ ) 0.090761646 0.091950355 RM S(δt ) 0.0045730039 0.004569379 M AX(δt ) 2.609342 2.600416733 Runge-Kutta 4th I Runge-Kutta 4th II RM S(δc ) 2.742427 ×10−6 1.808738 ×10−6 M AX(δc ) 0.013725044 0.006282631 −6 RM S(δv ) 5.786074 ×10 5.194458 ×10−6 M AX(δv ) 0.031592395 0.023821536 RM S(δθ ) 5.584277 ×10−5 5.422068 ×10−5 M AX(δθ ) 0.090713653 0.090712940 RM S(δt ) 0.004598423 0.004594660 M AX(δt ) 2.614308457 2.610048773 Taylor 1st AB2M3 RM S(δc ) 2.116881 ×10−6 5.364509 ×10−6 M AX(δc ) 0.008631502 0.030928467 RM S(δv ) 2.488386 ×10−5 1.171046 ×10−5 M AX(δv ) 0.129141765 0.056205591 −5 RM S(δθ ) 6.758674 ×10 5.451641 ×10−5 M AX(δθ ) 0.175486795 0.091844403 RM S(δt ) 0.004233903 0.004694498 M AX(δt ) 2.423062758 2.620592096 AB3M4 AB4M5 RM S(δc ) 2.334575 ×10−6 7.762851 ×10−6 M AX(δc ) 0.010761525 0.042727231 RM S(δv ) 9.201256 ×10−6 1.988151 ×10−4 M AX(δv ) 0.036529601 0.974722437 RM S(δθ ) 5.482375 ×10−5 5.609967 ×10−5 M AX(δθ ) 0.091634807 0.091435431 RM S(δt ) 0.004584769 0.005341836 M AX(δt ) 2.618315733 3.160109295 The 5th order polynomial is used to parameterize the geometric tool path in the experiments. Each segment of the tool path takes the following form:

IV. E XPERIMENTAL RESULTS

P i (u) = P5 u5 +P4 u4 +P4 u4 +P3 u3 +P2 u2 +P1 u+P0 (18)

The multiple step method can be obtained by approximating the function with m interpolation points. The AdamsBashforth method is an explicit multiple step method. Unlike the Runge-Kutta method, the algorithms need to compute the ODE function only once at each step. Remark III.4 Numerical integration usually has larger eruk−m−1 , u ˆk ], because ror outside the interpolation interval [ˆ the algorithm uses low order polynomial to approximate the ODE function. Generally the local discretization error can be big depending on the ODE function. In path interpolation, (t) f (t, u) = vvgd(u) , the local discretization error can be big depending on the prescribed tool path P (u). Usually the Adams-Bashforth method should not be used alone. To improve the accuracy, the implicit multiple step method can be utilized to correct the approximation error. The above multiple step method has local discretization error O(T m+1 ). Using the explicit multiple step method as predictor and the implicit multiple step method as corrector, the algorithm is mp −1

u ˆ0k+1

=u ˆk + T



aj f (tk−j , u ˆk−j ), n = 1, 2, · · · , N.

j=0

ˆk + T u ˆnk+1 = u

m c −1

bj f (tk−j , u ˆk−j ) + T b−1 f (tk+1 , u ˆn−1 k+1 ),

j=0

The iteration algorithm after N iterations generally has local discretization error O(T min(mc ,mp +N +1) ) where mp is the local discretization error of the predictor, mc > mp is the local discretization error of the corrector. If mc = mp + 1, usually one or two iterations will be enough for the accuracy. Too many iterations for predictor-corrector are not necessary. In general the global discretization error is one order less than the local discretization error provided that the ODE function is smooth enough. The multiple step method needs to compute the function N + 1 times.

The experiments is done on a retrofitted milling machine.

where P i represents the ith segment of the tool path,

2929

u ∈ [0, 1] is the parameter and Pj , j = [0, 1, · · · , 5] are the coefficients. The coefficients are generated randomly. The interpolation period is T = 1ms. The feedrate profile is S type. The parameters of the feedrate are Vmax = 0.06591 mm/ms, Amax = 6.8664 × 10−4 mm/ms2 , J = 4.2915 × 10−5 mm/ms3 . The various interpolation errors of the experiments are shown in Table 1. δt denotes the tracking error in the table. The units of the errors δc , δθ , δv and δt are mm, rad, mm/ms and mm/ms respectively. The actual position of the tool is measured from the encoder installed on the motor. From the table, we can see that the RungeKutta method is much better than the 1st order Taylor expansion method and the predictor-corrector method. If the computation resource is available, type I Runge-Kutta method of order 3 or type II Runge-Kutta method of order 4 is recommended. V. C ONCLUSION AND FURTHER WORK By examining different parametrization methods for free form curves, the geometric tool path and the dynamic tool path are defined, and the relations of the parameters are represented by the link function. From the fundamental theorem of calculus, the link function can be obtained by the ODE Eqn. (2). Thus the problem turns out to be an initial value problem for the ODE system. This unified problem formula can handle both path interpolation before feedrate scheduling and path interpolation after feedrate scheduling. Traditional path interpolation algorithms like DDA and digital increment algorithm can also be easily derived. The Taylor expansion methods, the Runge-Kutta methods and the multiple step predictor-corrector methods are provided to solve the path interpolation problem. Reliability, complexity and accuracy property of various methods are analyzed based on numerical computation theory. The mean square value and the maximal value of various interpolation errors are defined for comparison purpose. From numerical analysis, the simulation and the experiment results, we have the following conclusions: 1) The Runge-Kutta methods are better than the Taylor expansion methods and the predictor-corrector methods, since they are more reliable and more accurate. If the computation resource is available, the Runge-Kutta methods of order 3 or of order 4 are recommended; 2) The interpolation accuracy is also related to the feedrate, the interpolation period and the curvature of the tool path. Usually the interpolation period is fixed, determined by the hardware computation resource and the complexity of the algorithms. The curvature is an intrinsic geometry property of the tool path. To improve the accuracy, we can tune the feedrate; 3) The dynamic speed magnitude error is bigger when the acceleration happens or when the tool path is not smooth

enough. In practice, the feedrate should avoid variation as much as possible. From the experiments, we see that the feedrate is crucial for the product quality. It deserves more efforts. R EFERENCES [1] Y. Koren. Computer control of manufacturing systems. McGraw-Hill Book Company, New York, 1983. [2] Y. Altintas. Manufacturing automation: metal cutting mechanics, machine tool vibrations, and CNC design. Cambridge University Press, Cambridge, 2000. [3] J.J. Chou and D.C.H. Yang. On the generation of coordinated motion of five-axis CNC/CMM machines. ASME J. Engineering for Industry, 114(1):15–22, 1992. [4] J.T. Huang and D.C.H.Yang. A generalized inerpolator for command generation of parametric curves in computer-controlled machines. Proc. ASME Japan-USA Symp. Flexible Automation, 1992. [5] M. Shpitalni, Y. Koren, and C.C. Lo. Realtime curve interpolators. Computer-Aided Design, 26(11):832–838, 1994. [6] S.S. Yeh and P.L. Hsu. Adaptive feedrate interpolation for parametric curves with a confined chord error. Computer-Aided Design, 34(3):229–237, 2002. [7] S.H. Nam and M.Y. Yang. A study on a generalized parametric interpolator with real-time jerk-limited acceleration. Computer Aided Design, 36(1):27–36, 2004. [8] X. Liu, F. Ahmad, K. Yamazaki, and M. Mori. Adaptive interpolation scheme for NURBS curves with the integration of machining dynamics. Int. J. machine tools & manufacture, 45:433–444, 2005. [9] Y. Sun, J. Wang, and D. Guo. Guide curve based interpolation scheme of parametric curves for precision CNC machining. Int. J. machine tools & manufacture, 46:235–242, 2006. [10] M.T. Lin, M.S. Tsai, and H.T. Yau. Development of a dynamicsbased NURBS interpolator with real-time look-ahead algorithm. Int. J. machine tools & manufacture, 47:2246–2262, 2007. [11] M.S. Tsai, H.W. Nien, and H.T. Yau. Development of an integrated look-ahead dynamics-based NURBS interpolator for high precision machinery. Computer Aided Design, 40:554–566, 2008. [12] M.Y. Cheng, M.C. Tsai, and J.C. Kuo. Real-time NURBS command generators for CNC servo controller. Int. J. of Machine Tools & Manufacture, 42(7):801–813, 2002. [13] T. Yong and R. Narayanaswami. A parametric interpolator with confined chord errors, acceleration and deceleration for NC machining. Computer-aided Design, 35(13):1249–1259, 2003. [14] D.C.H. Yang and T. Kong. Parametric interpolator versus linear interpolator for precision CNC machining. Computer-Aided Design, 26(3):225–234, 1994. [15] W.T. Lei, M.P. Sung, L.Y. Lin, and J.J. Huang. Fast real-time NURBS path interpolation for CNC machine tools. Int. J. machine tools & manufacture, 47:1530–1541, 2007. [16] W.T. Lei and S.B. Wang. Robust real-time NURBS path interpolators. Int. J. machine tools & manufacture, In Press, 2009. [17] T.J. Tarn, N. Xi, and A.K. Bejczy. Path-based approach to integrated planning and control for robotic systems. Automatica, 32:1675–1687, 1996. [18] P. Deuflhard and F. Bornemann. Scientific computing with ordinary differential equations. Springer, Berlin, 2002. [19] G. Engeln-Mullges and F. Uhlig. Numerical algorithms with C. Springer, Berlin, 1996. [20] A. Quarteroni, R. Sacco, and F. Saleri. Numerical mathematics. Springer, Berlin, 2000. [21] H.R. Schwarz. Numerical analysis : a comprehensive introduction. Wiley, New York, 1989.

2930