Sage Journals: Discover world-class research

Abstract

This article presents an online three-axis non-uniform rational B-splines preprocessing and feedrate scheduling method with chord error, axial velocity, acceleration, and jerk limitations. A preprocessing method is proposed to accurately locate the critical points by reducing pre-interpolation feedrate in feedrate limit violation regions. In the preprocessing stage, the non-uniform rational B-splines curve is subdivided into segments by the critical points and the corresponding feedrate constraints are obtained. A sliding look-ahead window-based feedrate scheduling method is proposed to generate smooth feedrate profile for the buffered non-uniform rational B-splines segments. The feedrate profile corresponding to each non-uniform rational B-splines block is constructed according to the block length and the given limits of acceleration and jerk. The feedrate modification method for non-schedulable short blocks is also described which aimed at avoiding feedrate discontinuity at the junction of two non-uniform rational B-splines blocks. With the proposed method, a successful feedrate profile could be generated with sufficient look-ahead trajectory length in the buffer, which enables that the preprocessing and feedrate planning to be performed progressively online. Simulation and experimental tests with different non-uniform rational B-splines curves are carried out to validate the feasibility and advantages of the proposed method. The results show that the proposed method is capable of making a balance between the machining efficiency, machining precision, and computational complexity.

Keywords

Non-uniform rational B-splines interpolation feedrate scheduling curvature estimation chord error real time

Introduction

Conventional computer aided design (CAD)/computer aided manufacturing (CAM) systems usually fit a curved cutter paths proximately with a set of small linear/circular (G01, G02) blocks. During high speed computerized numerical control (CNC) machining, the discontinuities and abrupt direction changes of feedrate among blocks cause overshoots and rapid vibrations in the machine mechanics, degrading surface quality and machining accuracy. Modern CAD/CAM systems are able to express complex curves with parametric functions such as non-uniform rational B-splines (NURBS).¹ The parametric interpolator generates fine position commands from the NURBS curve directly without segmentation contour processing. Although there is no approximation error between the NURBS curve and the desired tool path, the processing speed must be reduced to ensure high-tracking accuracy in large curvature regions. In recent years, great efforts have been made on look-ahead feedrate planning.

For parametric curves, various features have been covered in studies on feedrate planning, including confined chord error/contour error,^2–4 acceleration/jerk limitations,⁵ servo dynamics constraints,^6–9 and constant material removal rate.¹⁰ In these works, the basic idea is to obtain the fastest allowable feedrate in feedrate-sensitive regions taking into account different constraints. With compromising to the speed in these areas, a feedrate profile is generated based on S-shaped acceleration/deceleration control. The most important step in this process is to determine the locations of feedrate crucial points and calculate corresponding tolerant velocity. The most common approach to find the feedrate-sensitive regions and critical points is to pre-interpolate the NURBS curve with a constant feedrate or a constant position increment. For example, Erkorkmaz and Altintas¹¹ introduced a jerk-limited feedrate profile generation algorithm for quintic spline. A reference trajectory is generated with a constant position increment before feedrate profile generation. ZY Jia et al.³ presented an NURBS interpolator with constant speed at feedrate-sensitive regions under drive and contour-error constraints. The feedrate-sensitive regions are found in an off-line preprocessing stage with constant feedrate adopted.

There is a trade-off between positioning accuracy and processing speed when determining the constant feedrate in finding the critical points. If a faster speed is adopted in the pre-interpolation step, which means longer displacement along the curve at each step, the referenced high curvature points are likely to be farther from the actual local maximum curvature points. On the other hand, slower feedrate generates more accurate location of critical points, but large amount of calculation is induced in the meanwhile, making it inappropriate to real-time application. This article presents a local fine pre-interpolation method which balances critical point positioning accuracy and processing speed. During the iterative pre-interpolation process, the feedrate is reduced to a lower value at feedrate-sensitive regions to generate reference points more densely, such that the critical point is approximated more accurately. The proposed local fine preprocessing method can significantly improve the critical point positioning accuracy without a large increasing the computation time.

In most prior works, a predefined kinematic profile is used to generate smooth feedrate profiles. In Erkorkmaz and Altintas,¹¹ the formulation and implementation of jerk-limited S-shaped polynomial feedrate profile are described in great detail. This form of S-shaped acceleration (ACC)/deceleration (DEC) profile is widely used in many researches.^12–14 The S-shaped polynomial feedrate profiles have complex expressions and involve many parameters. Lee et al.¹⁵ constructed a velocity profile using trigonometric sine function. The sine-curve velocity profile has a more concise expression of formula than S-shaped velocity profile. Y Wang et al.¹⁶ proposed a sine function–based feedrate scheduling method so as to generate jerk continuous feedrate profile. The non-schedulable situation one may encounter when scheduling feedrate for a short NURBS block is not discussed detailedly in Lee et al.¹⁵ and Wang et al.¹⁶ In this article, a jerk-limited feedrate function is constructed using cosine function. According to the length of an NURBS block, four types of situations are analyzed so as to generate appropriate form of feedrate profile, including the non-schedulable situation.

In order to eliminate the feedrate violation between the non-schedulable block and its adjacent blocks, a look-ahead module is needed to check feedrate limits along the curve. Zhong et al.¹⁷ proposed a look-ahead method with dynamic look-ahead length. The look-ahead length is calculated as the time required for a full stop. However, the influence of non-schedulable block to the adjacent blocks is not considered. The feedrate correction of non-schedulable blocks will cause reschedule of their adjacent blocks. Erkorkmaz et al.¹⁸ proposed a windowing-based feedrate optimization algorithm. But the connection profile between two adjacent look-ahead windows needs to be rescheduled. In this article, a sliding window-based look-ahead method is proposed to identify the non-schedulable blocks ahead of schedule. The windowed look-ahead method is performed progressively on fixed length of trajectory, so there is no need to preprocess the NURBS curve completely before feedrate scheduling. Consequently, the preprocessing and feedrate profile generation could run simultaneously in online space, which is beneficial for machining long tool paths. By comparison, the feedrate scheduling is accomplished in the off-line stage in some prior works.^3,15

Since the feedrate profile generation is displacement-controlled, and the NURBS interpolation uses chord length to approximate the curve length by its very nature, the terminal error always exists at the end of an NURBS block when interpolating the NURBS curve with the scheduled feedrate profile. In this article, a compensation feedrate profile scheduling method is proposed to eliminate the terminal error, which also considers the rounding error at the transition point between a constant speed stage and a variable speed stage.

The innovative contribution of this article is summarized as a systematic NURBS interpolator with online NURBS preprocessor and look-ahead feedrate generator, which is favorable to long NURBS tool paths machining. The significances and advantages of the proposed NURBS interpolator are as follows: (1) the proposed local fine preprocessing method can significantly improve the critical point positioning accuracy without a large increasing the computation time; (2) the proposed sliding window-based look-ahead feedrate scheduling method could generate successful feedrate profile with limited length of reference trajectory, and hence, there is no need to preprocess the NURBS curve completely before feedrate scheduling; and (3) the interpolation terminal error is compensated while keeping the smoothness of the feedrate profile, and the feedrate fluctuation is decreased significantly by employing parameter compensation method, which is conductive to guaranteeing the machining precision and protecting machine tools from unwanted vibration.

The rest of this article is organized as follows. The “Development of the interpolation scheme” section presents some background knowledge of NURBS interpolation, and the architecture of the proposed NURBS interpolator is also described. The “Feedrate scheduling algorithm” section describes the proposed NURBS preprocessing and feedrate scheduling methods. The “Simulation and experimental results” section presents the simulation and experimental results. Conclusions are summarized in the “Conclusion” section.

Development of the interpolation scheme

In this section, the definition of NURBS curve and basic interpolation method are reviewed, and the methods of curvature estimation are presented. Finally, the overall architecture of the feedrate planning scheme is explained.

Definitions of NURBS curve

An NURBS curve is represented with equation (1)¹

C (u) = \frac{\sum_{i = 0}^{n} N_{i, p} (u) w_{i} P_{i}}{\sum_{i = 0}^{n} N_{i, p} (u) w_{i}}

(1)

where u is an arbitrary parameter, and normally $0 \leq u \leq 1$ . $P_{i}$ is the control point, $w_{i}$ is the weight factor of $P_{i}$ , and p is the degree of the NURBS curve. $N_{i, p} (u)$ is the pth-degree B-spline basis function defined on the non-uniform knot vector $U = {u_{0}, u_{1}, \dots, u_{n + p + 1}}$

\begin{matrix} N_{i, 0} (u) = {\begin{matrix} 1 if u_{i} \leq u \leq u_{i + 1} \\ 0 otherwise \end{matrix} \\ \begin{matrix} N_{i, p} (u) = \frac{u - u_{i}}{u_{i + p} - u_{i}} N_{i, p - 1} (u) \\ + \frac{u_{i + p + 1} - u}{ui + p + 1 - u_{i + 1}} N_{i + 1, p - 1} (u) \end{matrix} \end{matrix}

Interpolation of NURBS curve

To generate motion trajectory using the sampled-data interpolation algorithm, the position command at each sampling period $T_{s}$ is calculated by mapping path increment $Δ s$ to parameter u, following the desired tool path. By neglecting high-order terms of the second-order Taylor expansion formula, a commonly used feedrate interpolation algorithm can be given as²

\begin{matrix} u_{i + 1} = & u_{i} + \frac{v_{i} T_{s} + a_{i} T_{s}^{2} / 2}{\sqrt{{(\overset{\cdot}{x})}^{2} + {(\overset{\cdot}{y})}^{2} + {(\overset{\cdot}{z})}^{2}}} |_{t = t_{i}} \\ - \frac{{(v_{i} T_{s})}^{2} (\overset{\cdot}{x} \overset{\cdot\cdot}{x} + \overset{\cdot}{y} \overset{\cdot\cdot}{y} + \overset{\cdot}{z} \overset{\cdot\cdot}{z})}{2 {({\overset{\cdot}{x}}^{2} + {\overset{\cdot}{y}}^{2} + {\overset{\cdot}{z}}^{2})}^{2}} |_{t = t_{i}} \end{matrix}

(2)

where $v_{i}$ and $a_{i}$ are feedrate and acceleration at $t = t_{i}$ , respectively. $u_{i + 1}$ indicates the next parameter value of position command $C (u_{i + 1})$ . For constant feedrate interpolation, $Δ s = v_{i} T_{i}$ . $\overset{\cdot}{x}$ and $\overset{\cdot\cdot}{x}$ are defined as follows

\overset{\cdot}{x} = C' (x (u)) = \frac{dC (x (u))}{du}, \overset{\cdot\cdot}{x} = C ″ (x (u)) = \frac{d^{2} C (x (u))}{d u^{2}}

Curvature and chord error estimation

Curvature is the most important information in feedrate planning, which is widely used to estimate chord error and contour error. For example, the chord error $δ_{i}$ at ith iteration is expressed in equation (3)

δ_{i} \approx ρ_{i} - \sqrt{ρ_{i}^{2} - {(\frac{L_{i}}{2})}^{2}}, ρ_{i} = \frac{1}{κ_{i}}

(3)

where $ρ_{i}$ and $κ_{i}$ are the radius of curvature and curvature at the parameter value $u_{i}$ . And $L_{i}$ is the curve length from $C (u_{i})$ to $C (u_{i + 1})$ which is approximated by $| V_{i} T_{s} |$ .

For parametric curves, the curvature $κ_{i}$ is given by equation (4)

κ_{i} = \frac{| C' (u_{i}) \times C ″ (u_{i}) |}{| C' (u_{i}) |^{3}} = \frac{| (\overset{\cdot}{x}, \overset{\cdot}{y}, \overset{\cdot}{z}) \times (\overset{\cdot\cdot}{x}, \overset{\cdot\cdot}{y}, \overset{\cdot\cdot}{z}) |}{| (\overset{\cdot}{x}, \overset{\cdot}{y}, \overset{\cdot}{z}) |^{3}} |_{t = t_{i}}

(4)

Real-time feedrate scheduling scheme

In order to generate smooth feedrate profile for both short linear blocks and NURBS curves, a real-time look-ahead feedrate scheduling method is developed. The flowchart of the proposed method is shown in Figure 1. An NURBS curve is pre-interpolated using the proposed Local Fine Pre-interpolation method for critical point detection. After pre-interpolation, the NURBS curve is subdivided into small segments by a set of reference points. The curvature at each reference point is also computed using equation (4) during pre-interpolation. Next, by scanning along the reference trajectory, critical points with local maximum curvature are detected. All the information of each reference point is stored in a buffer, including Cartesian coordinates, curvature, corresponding NURBS parameter value, length of the current segment, estimated chord error, and whether it is marked as a critical point. The look-ahead feedrate scheduling module reads points cyclically from the buffer. By employing the proposed windowed look-ahead feedrate scheduling method, the system is able to keep running smoothly as long as there is adequate trajectory point data for generating a successful feedrate profile in the buffer. Hence, there is no need to pre-interpolate the curve completely before feedrate planning, thereby making the preprocessing stage to be applied for online use. The generated feedrate profile is utilized for fine interpolation to compute position commands in servo period. Parameter compensation method is also applied to avoid feedrate fluctuation.

Figure 1.

Flowchart of the feedrate scheduling method.

Feedrate scheduling algorithm

Real-time NURBS curve preprocessing

The primary role of the NURBS curve preprocessing stage is to scan possible feedrate violation points before feedrate profile generation. As described above, the curve is usually pre-interpolated into a set of reference points with constant position increment $Δ s$ . Both feedrate limitations and acceleration limit are estimated for each reference point. Critical points are determined according to the estimated feedrate limits. The curve is split into small NURBS blocks by the critical points and ready for the next stage of feedrate scheduling.

Feedrate limit

Four feedrate limitations are considered, including command feedrate, the maximum axial velocity, chord error limits, and centripetal acceleration limit.

First, the feedrate should not exceed the command feedrate $F_{cmd}$

F_{\lim, 1} (u_{i}) = F_{cmd}

(5)

Second, the feedrate is constrained by the maximum axial velocity

F_{\lim, 2} (u_{i}) = \min (\frac{V_{x}}{| α |}, \frac{V_{y}}{| β |}, \frac{V_{z}}{| γ |})

(6)

where $V_{x}, V_{y}, V_{z}$ are the maximum velocity of each axis, and $α$ , $β$ , and $γ$ are the first derivative factors

α = \frac{\overset{\cdot}{x} (u_{i})}{| \overset{\cdot}{C} (u_{i}) |}, β = \frac{\overset{\cdot}{y} (u_{i})}{| \overset{\cdot}{C} (u_{i}) |}, γ = \frac{\overset{\cdot}{z} (u_{i})}{| \overset{\cdot}{C} (u_{i}) |}

(7)

According to equation (3), the chord error–limited feedrate is given as

F_{\lim, 3} (u_{i}) = \frac{2}{T_{s}} \sqrt{ρ_{i}^{2} - {(ρ_{i} - δ_{\max})}^{2}}

(8)

where $δ_{\max}$ is the tolerant chord error.

Centripetal acceleration is proportional to the square of feedrate

a_{n} = \frac{v_{i}^{2}}{ρ_{i}}

(9)

and it is limited by the axial acceleration limits

a_{n} \leq \min (\frac{A_{x}}{| β |}, \frac{A_{y}}{| α |})

(10)

Therefore, the centripetal acceleration bounded feedrate is given as

F_{\lim, 4} (u_{i}) = \sqrt{ρ_{i} \min (\frac{A_{x}}{| β |}, \frac{A_{y}}{| α |})}

(11)

The final feedrate limitation for a reference point in the curve is given by

F_{\lim} (u_{i}) = \min (F_{\lim, 1} (u_{i}), F_{\lim, 2} (u_{i}), F_{\lim, 3} (u_{i}), F_{\lim, 4} (u_{i}))

(12)

It is possible to add extra feedrate constraints in equation (12).

Acceleration limit

Axial acceleration limits $A_{x}$ , $A_{y}$ , and $A_{z}$ are used to confine tangential acceleration $A_{t}$ at each reference point

A_{t} (u_{i}) = \min (\frac{A_{x}}{| α |}, \frac{A_{y}}{| β |}, \frac{A_{z}}{| γ |})

(13)

When scheduling feedrate for an NURBS block, the acceleration constraint $A_{\max}$ is defined as the minimum tangential acceleration limit of the reference points within the NURBS block

A_{\max} = \min (A_{t} (u_{1}), A_{t} (u_{2}), \dots, A_{t} (u_{n}))

(14)

where n is the number of reference points in the NURBS block.

Local fine preprocessing method

To schedule feedrate profiles, it is necessary to find out the critical points with local minimum permissible feedrate from the reference points. However, the reference points are generated with rough interpolation; there is an error between the estimated reference points and the theoretical critical point. To approximate the theoretical critical points more precisely, the given constant increment (or feedrate) should be small enough. But low pre-interpolation feedrate introduces large computational cost to the preprocessing task.

In order to solve this problem, a local fine preprocessing method is proposed, as shown in Algorithm 1. The preprocessor interpolates the NURBS curve with a fast feedrate (e.g. 100 mm/s). Three reference points form a critical region if equation (15) is met

{\begin{matrix} F_{\lim} (u_{i}) < F_{\lim} (u_{i - 1}) \\ F_{\lim} (u_{i}) < F_{\lim} (u_{i + 1}) \end{matrix}

(15)

Algorithm 1. Local fine pre-interpolation method.
1: $i = 0$ , $u_{0} = 0$ , $V = 100 mm / s$ , $flag = False$
2: while $u_{i} < 1.0$ do
3: $u_{i + 1} = FistOrderTaylorExpansion (u_{i}, V)$
4: $F_{\lim} (u_{i + 1}) = \min (F_{\lim, 1}, F_{\lim, 2}, F_{\lim, 3})$
5: if $F_{\lim} (u_{i}) \leq \min (F_{\lim} (u_{i - 1}), F_{\lim} (u_{i + 1}))$ then
6: if $flag = True$ then
7: $flag = False$
8: $V = 100 mm / s$
9: $C (u_{i})$ is a critical point. Continue
10: else
11: $flag = True$
12: $V = 5 mm / s$
13: $i = i - 1$
14: end if
15: else
16: $i = i + 1$
17: end if
18: end while

If a critical region $(C (u_{i - 1}), C (u_{i + 1}))$ is detected, the preprocessor re-interpolates the critical region with a low feedrate (e.g. 5mm/s). The critical point is selected from the newly generated reference points, which is more close to the actual critical point.

Jerk-limited trigonometric velocity profile

Trigonometric velocity profile has a concise expression of formula, while the widely used S-shaped polynomial velocity scheduling method¹¹ consists of seven stages and involves more parameters. In this section, the implementation of trigonometric velocity function is presented more concisely and clearly.

As shown in Figure 2, the velocity function of one velocity transition process is given as equation (16)

v (t - t_{0}) = v_{1} + \frac{1}{2} (v_{2} - v_{1}) [\cos (\frac{t - t_{0}}{t_{m}} π + π) + 1]

(16)

which can be simplified to equation (17)

v (t - t_{0}) = \frac{1}{2} (v_{2} + v_{1}) - \frac{1}{2} (v_{2} - v_{1}) \cos \frac{t - t_{0}}{t_{m}} π

(17)

where $v_{1}$ and $v_{2}$ are the start velocity and target velocity, and $t_{m}$ is the consumption time of a complete ACC/DEC process; $v (0) = v_{1}$ and $v (t_{m}) = v_{2}$ .

Figure 2.

Trigonometric feedrate profile from $v_{1}$ to $v_{2}$ .

The acceleration and jerk functions could be obtained by taking first and second derivatives of equation (17) with respect to time

\begin{matrix} a (t - t_{0}) = \frac{π}{2 t_{m}} (v_{2} - v_{1}) \sin \frac{t - t_{0}}{t_{m}} π \\ J (t - t_{0}) = \frac{π^{2}}{2 t_{m}^{2}} (v_{2} - v_{1}) \cos \frac{t - t_{0}}{t_{m}} π \end{matrix}

(18)

There is only one variable $t_{m}$ to be determined to generate a feedrate profile using equation (17). However, $t_{m}$ can be determined by applying acceleration and jerk limitations to equation (18)

\begin{matrix} | a (t - t_{0}) | \leq A_{\max} \\ | J (t - t_{0}) | \leq J_{\max} \end{matrix}

(19)

Solving equations (18) and (19) yields the limitations of $t_{m}$

\begin{matrix} t_{m} \geq \frac{| v_{2} - v_{1} |}{2 A_{\max}} π \\ t_{m} \geq \sqrt{\frac{π^{2}}{2 J_{\max}} | v_{2} - v_{1} |} \end{matrix}

(20)

Thereby, $t_{m}$ can be determined by taking the minimum allowable value

t_{m} = \max (\frac{| v_{2} - v_{1} |}{2 A_{\max}} π, \sqrt{\frac{π^{2}}{2 J_{\max}} | v_{2} - v_{1} |})

(21)

Once $t_{m}$ is determined, the displacement from $v_{1}$ to $v_{2}$ is calculated using equation (22)

s = \int_{t_{0}}^{t_{0} + t_{m}} v (t - t_{0}) dt = \frac{v_{1} + v_{2}}{2} t_{m}

(22)

To demonstrate the features of the jerk-limited trigonometric velocity profile, the feedrate profile of a $15 - mm$ line segment is generated using both S-shaped feedrate scheduling method and the trigonometric feedrate scheduling method, as shown in Figure 3. The start velocity is $v_{s} = 5 mm / s$ , the end velocity is $v_{e} = 15 mm / s$ , and the maximum feedrate is $F = 70 mm / s$ . With the same acceleration and jerk limitations, the two feedrate profiles are modulated smoothly, but the acceleration and jerk profiles of the trigonometric feedrate scheduling method change more flexibly, which is helpful to keep the cutting process stable. But it should also be noticed that the total machining time of trigonometric feedrate scheduling method is a little longer than S-shaped feedrate scheduling method.

Figure 3.

Feedrate profile of a $15 - mm$ line segment.

Consequently, the advantages of the trigonometric feedrate scheduling method are summarized as concise expression of formula, smoother acceleration, and jerk profiles. And the disadvantage is that the production efficiency will be degraded slightly as compared with S-shaped feedrate scheduling method.

Feedrate profile generation for an NURBS block

The NURBS curve is divided into blocks by the critical points. Each NURBS block is taken as an input unit of the feedrate scheduling procedure. Suppose $C (u_{m})$ and $C (u_{n})$ are two adjacent critical points and their chord error confined feedrates are denoted as $V_{a} (u_{m}) = v_{1}$ and $V_{a} (u_{n}) = v_{2}$ . To schedule the feedrate profile from $v_{1}$ to $v_{2}$ , it is necessary to calculate the arc length of the NURBS block accurately. In this article, the curve length S of the NURBS block is estimated using the Adaptive Simpson’s rule.^19,20

There are four types of situation one may encounter to schedule feedrate for an NURBS block, as shown in Table 1. The judgment condition is based on the estimated curve length S.

Table 1.

Different cases of feedrate profile generation for each NURBS block.

Type 1 $(S \geq s_{ma} + s_{md})$	$t_{ma} = \max (\frac{\| v_{\max} - v_{1} \|}{2 A_{\max}} π, \sqrt{\frac{π^{2}}{2 J_{\max}} \| v_{\max} - v_{1} \|})$ $t_{md} = \max (\frac{\| v_{2} - v_{\max} \|}{2 A_{\max}} π, \sqrt{\frac{π^{2}}{2 J_{\max}} \| v_{2} - v_{\max} \|})$ $s_{ma} = \frac{1}{2} (v_{\max} + v_{1}) t_{ma}$ $s_{md} = \frac{1}{2} (v_{\max} + v_{2}) t_{md}$ $s_{c} = S - s_{ma} - s_{md}$ $t_{c} = \frac{s_{c}}{v_{\max}}$
Type 2 $(v_{1} < v_{2}$ and $s_{a} \leq S < s_{ma} + s_{md})$	$t_{a} = \max (\frac{\| v_{2} - v_{1} \|}{2 A_{\max}} π, \sqrt{\frac{π^{2}}{2 J_{\max}} \| v_{2} - v_{1} \|})$ $s_{a} = \frac{1}{2} (v_{1} + v_{2}) t_{a}$ $s_{c} = S - s_{a}$ $t_{c} = \frac{s_{c}}{t_{c}}$	$s_{a} = \frac{1}{2} (v_{m} + v_{1}) t_{a}$ $s_{d} = \frac{1}{2} (v_{m} + v_{2}) t_{d}$ $S = s_{a} + s_{d}$
Type 3 $(v_{1} > v_{2}$ and $s_{d} \leq S < s_{ma} + s_{md})$	$t_{d} = \max (\frac{\| v_{2} - v_{1} \|}{2 A_{\max}} π, \sqrt{\frac{π^{2}}{2 J_{\max}} \| v_{2} - v_{1} \|})$ $s_{d} = \frac{1}{2} (v_{1} + v_{2}) t_{d}$ $s_{c} = S - s_{d}$ $t_{c} = \frac{s_{c}}{t_{c}}$
Type 4 $(S < s_{a}$ or $S < s_{d})$	Non-schedulable block

NURBS: non-uniform rational B-splines.

For Type 1, the NURBS block is long enough and the maximum velocity $v_{\max} = F$ is reachable. There are three stages in the changing process from $v_{1}$ to $v_{2}$ : $v_{1} \overset{acc}{\to} v_{\max} \overset{const}{\to} v_{\max} \overset{dec}{\to} v_{2}$ . The consumption times ( $t_{ma}$ , $t_{md}$ ) and the displacements ( $s_{ma}$ , $s_{md}$ ) along the curve of both acceleration and deceleration stages are calculated using the equitations in Table 1. The curve length for constant feedrate stage is $s_{c} = S - s_{ma} - s_{md}$ . The feedrate profile is shown in Figure (a) in Table 1.

For Type 2 and Type 3, the curve block is short and the maximum feedrate is not reachable. There are two approaches to plan feedrate for such an NURBS block. As shown in Figures (b) and (c) in Table 1, approach 1 divides the feedrate profile into two stages: one is a constant feedrate stage, another is an ACC or DEC stage. The uniform segment is always planned at the higher speed end of the NURBS block. The equitations of the first approach is shown in Table 1. The second approach is shown in Figure (d) of Table 1. The feedrate accelerates from $v_{1}$ to $v_{m}$ , then decelerates to $v_{2}$ , where $v_{m} < v_{\max}$ . $t_{a}$ , $t_{d}$ , $v_{m}$ , $s_{a}$ , and $s_{d}$ could be calculated by solving the following equations

{\begin{matrix} t_{a} = \max (\frac{| v_{m} - v_{1} |}{2 A_{\max}} π, \sqrt{\frac{π^{2}}{2 J_{\max}} | v_{m} - v_{1} |}) \\ t_{d} = \max (\frac{| v_{2} - v_{m} |}{2 A_{\max}} π, \sqrt{\frac{π^{2}}{2 J_{\max}} | v_{2} - v_{m} |}) \\ s_{a} = \frac{1}{2} (v_{m} + v_{1}) t_{a} \\ s_{d} = \frac{1}{2} (v_{m} + v_{2}) t_{d} \\ S = s_{a} + s_{d} \end{matrix}

(23)

Compared with approach 1, approach 2 takes less time to travel the same NURBS block. However, the feedrate and acceleration fluctuate in a short time, which could possibly lead to machining vibration. Therefore, approach 1 is chosen as the default method when planning feedrate for short curve blocks.

For Type 4, the curve block is too short and the target velocity is not reachable with the limitations of acceleration and jerk, as shown in Figures (e) and (f). To avoid feedrate discontinuity, it is necessary to perform forward look-ahead feedrate modification at each junction of the NURBS blocks. For the case in Figure (e), the start velocity $v_{1}$ should be reduced so that the target velocity $v_{2}$ is reachable within the limited curve length. On the contrary, the target velocity $v_{2}$ should be reduced in Figure (f). A sliding window-based look-ahead feedrate scheduling method is proposed in the next section, which could modify the junction feedrate of short blocks ahead of schedule.

Windowed look-ahead feedrate scheduling method

In prior researches, the NURBS curve is pre-interpolated completely and all the subdivided blocks are sequentially analyzed by the look-ahead module to determine the feedrate at each joint. This kind of look-ahead method is not suitable for real-time application. In this article, a sliding look-ahead window (SLW)-based feedrate scheduling method is proposed in which the look-ahead process is conducted progressively in real time.

As discussed in the previous section, the purpose of look-ahead is to eliminate violation by adjusting junction feedrate of Type 4 short blocks. However, once the feedrate of a junction is modified, the feedrate profile of the adjacent block should be rescheduled. The look-ahead window should be long enough to cover the travel length of the modified feedrate profile.

It can be inferred from equations (21) and (22) that the maximum travel length of a feed transition happens when decelerating from the largest feedrate to zero

L_{smax} = \frac{v_{\max} - 0}{2} t_{m} = \frac{v_{\max}}{2} \max (\frac{v_{\max} π}{2 A_{\max}}, \sqrt{\frac{v_{\max} π^{2}}{2 J_{\max}}})

(24)

which means that any NURBS block longer than $L_{smax}$ is schedulable. In this article, the look-ahead window length is set to $L_{w} = 3 L_{smax}$ , which is sufficient to cover the modified feedrate profile.

The diagram of a look-ahead window is shown in Figure 4. A look-ahead window $W_{i}$ is separated into three equal parts: $W_{i}^{1}$ , $W_{i}^{2}$ , and $W_{i}^{3}$ . At the end of each feedrate scheduling cycle, the look-ahead window slides forward to another by a third of its length $L_{smax}$ . $W_{i}^{2}$ and $W_{i}^{3}$ become $W_{i + 1}^{1}$ and $W_{i + 1}^{2}$ of the next window $W_{i + 1}$ , and newly buffered reference points comprise the third part of $W_{i + 1}$ . This tri-step forward look-ahead strategy guarantees that the critical points with feedrate violation are always located in the third part of the look-ahead window because the length of a non-schedulable block is always shorter than $L_{smax}$ .

Figure 4.

Diagram of look-ahead window.

The flowchart of the SLW feedrate scheduling method is shown in Figure 5. First, the reference points are pushed into the look-ahead window from the preprocessing buffer. Then the look-ahead window is checked for any non-schedulable short blocks. If a non-schedulable block is detected, feedrate correction is executed before scheduling feedrate. Afterward, according to the existence of critical points in $W_{i}^{2}$ and $W_{i}^{3}$ , four different cases are handled as shown in Figure 6.

Figure 5.

Flowchart of the SLW feedrate scheduling method.

Figure 6.

Different cases of look-ahead feedrate scheduling of SLW.

In case A, there exist critical points in $W_{i}^{2}$ . The feedrate profile is generated for the tool path before the last critical point in $W_{i}^{2}$ . In case B, there are no critical points in both $W_{i}^{2}$ and $W_{i}^{3}$ ; the feedrate profile is generated until the last reference point. In case C and case D, the deceleration distance is calculated and the deceleration start point is determined. If the deceleration point is located in $W_{i}^{2}$ , the feedrate profile is scheduled to the deceleration point, or else the feedrate profile is generated to the last reference point in $W_{i}^{2}$ .

Feedrate correction for non-schedulable blocks

As described in the previous section, there are two feedrate modification situations for Type 4 blocks in Table 1. The first one is to modify the start velocity when the target velocity is too low and unreachable. The second one is to modify the target velocity when the target velocity is too high. Since the blocks are scheduled sequentially, and the start velocity of the non-schedulable block is also the target velocity of the previous block, the modification of start velocity will cause re-planning of the previous blocks. On the other hand, the second situation has no influence on the previous scheduled feedrate profile. The look-ahead feedrate modification strategy for the first case is discussed as follows.

As the look-ahead window moves forward, a non-schedulable block may be covered by the look-ahead window completely or partly, as shown in Figure 7, where EF is a non-schedulable block and $V_{E}$ needs to be modified since $V_{F}$ is lower and unreachable. In Figure 7(a), EF is completely included in $W_{i}^{3}$ . Blocks before point B have been scheduled in the previous look-ahead window. The valid look-ahead distance is from the last critical point in $W_{i}^{1}$ to the last critical point in $W_{i}^{3}$ $(BF)$ , which is denoted as $L_{look}$ . In Figure 7(b), EF is partly covered by $W_{i}$ , so BC and CD are scheduled without considering feedrate violation at F. However, F is available for look-ahead in the next window $W_{i + 1}$ . Obviously, $L_{look} > L_{smax}$ in both Figure 7(a) and (b), which means that there is sufficient travel length to decelerate to $V_{F}$ after adjusting $V_{E}$ .

Figure 7.

Two cases of non-schedulable block.

In this article, the bisection search algorithm proposed by M Heng and K Erkorkmaz²¹ is adopted to correct the junction velocities of the non-schedulable blocks, as shown in Figure 8. Different with Heng and Erkorkmaz,²¹ the feedrate search space in this article is [ $F_{start}$ , $F_{end}$ ], where $F_{start}$ and $F_{end}$ are the start and end velocity of the non-schedulable block. At each iteration, the bisected value $f_{mid}$ is tested against the schedulability conditions in Table 1. If there is a violation, then $f_{mid}$ becomes the high bound of the next iteration’s search space and the previous low bound remains the same. Otherwise, $f_{mid}$ becomes the new low bound. The search iteration stops when the search space is shorter than $F_{tol}$ . On the last iteration, if $f_{mid}$ is feasible, then it becomes the new junction feedrate $F_{new}$ . On the other hand, if it is not feasible, then the new junction feedrate is the last feasible feed found in the previous iteration. After junction feedrate correction, the Type 4 non-schedulable blocks are translated into Type 2 or Type 3 blocks.

Figure 8.

Bisection search algorithm for a feasible feed.²¹

By now, using the windowed look-ahead window feedrate scheduling method, a set of consecutive and successful feedrate profile segments are generated and ready to be used for real-time interpolation, although the feedrate profile have not been generated completely.

Terminal error compensation of NURBS blocks

Since the length $S_{i}$ of each NURBS block is estimated using the Adaptive Simpson’s rule, estimation error always exists and it may cause a problem of terminal error after interpolation.¹⁵ On the other hand, there is a rounding error at the transition point between a constant speed stage and a variable speed stage, which will also cause terminal error of interpolation. As shown in Figure 9, the next interpolation period at the transition point consists of a constant speed stage and a deceleration stage, and the feedrate for this interpolation period is hard to calculate.³ In this article, the deceleration start point is moved forward from $C (u_{d})$ to the last constant speed point $C (u_{i})$ . As a result, the scheduled feedrate profile ends up at $C (u_{j})$ ahead of the critical point $C (u_{cr})$ , which produces a terminal error $| C (u_{cr}) - C (u_{j}) |$ . The terminal error caused by curve length estimation error is also included in $| C (u_{cr}) - C (u_{j}) |$ .

Figure 9.

Transition point and terminal error compensation.

To compensate the error between $C (u_{j})$ and $C (u_{cr})$ , the interpolation continues from $u_{j}$ with constant feedrate $v_{cr}$ until $u_{j + n} > u_{cr}$ , as shown in Figure 9. However, this method does not work when the terminal feedrate $v_{cr}$ of the NURBS block is zero $(v_{cr} = 0)$ . To address this problem, the $[- (π / 2), (3 π / 2)]$ interior sine curve is utilized to construct a compensation feedrate profile between $C (u_{j})$ and $C (u_{cr})$ , as shown in Figure 10. The feedrate equation is represented as

v_{c} = \frac{v_{m}}{2} [\sin (\frac{2 π (t - t_{j})}{t_{m}} - \frac{π}{2}) + 1]

(25)

Figure 10.

Compensation feedrate profile.

First, the curve length $s (u_{j}, u_{cr})$ is estimated using the Adaptive Simpson’s rule. Then, $v_{m}$ and $t_{m}$ could be obtained from

{\begin{matrix} t_{m} = 2 \max (\frac{| v_{m} - 0 |}{2 A_{\max}} π, \sqrt{\frac{| v_{m} - 0 | π^{2}}{2 J_{\max}}}) \\ s (u_{j}, u_{cr}) = \frac{v_{m}}{2} t_{m} \end{matrix}

(26)

Consequently, the terminal error of interior NURBS block whose end velocity is nonzero is compensated by continuous interpolation with $v_{cr}$ until the critical point is reached. And the terminal error of the last NURBS block of which the end velocity is zero is compensated by adding a compensation feedrate stage.

Simulation and experimental results

In this section, simulation tests are performed on some NURBS tool paths in order to demonstrate the feasibility and applicability of the proposed feedrate scheduling method. The proposed NURBS preprocessing method and look-ahead feedrate scheduling method are realized using MATLAB language. The simulation platform is an Intel Celeron J1900–based personal computer that runs at 2.0 GHz.

Pre-processing method validation

A trident-shape NURBS curve is employed to test the proposed NURBS preprocessing method. The geometry model and control polygon of the trident shape are shown in Figure 11, and its NURBS parameters are as follows:

Order p: 2;

Knot vector ${U_{i}}$ : {0,0,0,0.2,0.4,0.6,0.8,1,1,1};

Control points ${P_{i}}$ : {[10,0] [0,20] [8,8] [10,20] [12,8] [20,20] [10,0]};

Weights ${w_{i}}$ : {1, 1, 1, 1, 1, 1, 1}.

Figure 11.

Geometry model of the trident-shape curve.

To clearly demonstrate the advantage of the proposed preprocessing method, only chord error constraint is considered in this experiment. Hence, the critical points are exactly the high curvature points. There are five sharp corners along the trident curve, which are marked as A, B, C, D, and E in Figure 11. By employing the local fine preprocessing method, the critical point parameters and the corresponding curvature values are obtained. The reference points at sharp corner A and curvature profile are shown in Figure 12. Compared to traditional constant feedrate preprocessing method, the proposed local fine preprocessing method generates reference points more densely around the sharp corner, as shown in Figure 12(a) and (c). Hence, the high curvature critical points are approximated more accurately using the proposed method. In Figure 12(b), the estimated curvature values of the critical points A and E are $κ_{A} = 20.33$ and $κ_{E} = 26.43$ , while the values in Figure 12(d) are $κ_{A} = 32.18$ and $κ_{E} = 32.06$ . With the traditional constant feedrate preprocessing method, there are large errors between the estimated curvature extremes and the theoretical values at sharp corners, which have great influence in calculating the tolerant feedrate using equation (8). As shown in Figure 12(e), the chord error–limited feedrate limitation is supposed to be equal at sharp corners A and E; however, $V_{A}$ is much higher than $V_{E}$ due to the curvature estimation error. This problem is addressed by adopting the proposed local fine preprocessing method, as shown in Figure 12(f).

Figure 12.

Reference points at sharp corner A and curvature profiles: (a) constant feedrate preprocessing method when $F = 70 mm / s$ ; (b) curvature profile of constant feedrate method with $F = 70 mm / s$ ; (c) proposed local fine preprocessing method; (d) curvature profile of the local fine preprocessing method; (e) feedrate profile generated with constant preprocessing feedrate, $F = 70 mm / s$ ; and (f) feedrate profile using local fine preprocessing method.

The computation time of the preprocessing stage is estimated using the MATLAB platform, as shown in Table 2. To achieve the same curvature estimation accuracy as the local fine preprocessing method, the pre-interpolation feedrate of constant feedrate method should be reduced to $5 mm / s$ ; however, the preprocessing stage becomes very time-consuming. In contrast, the local fine preprocessing method takes less computation time.

Table 2.

Comparison of the results of two preprocessing methods for the trident curve test.

Method	Feedrate $(mm / s)$	Number of computation cycles	Computation time with 2.0 GHz CPU $(ms)$	Average cycle time $(ms)$
Constant feedrate method	70	868	2125	2.448
Constant feedrate method	5	12,130	26,866	2.215
Local fine method	Normal: 70 Fine: 5	999	4138	4.142

The results show that the presented local fine preprocessing method can significantly improve the curvature estimation accuracy without a large increasing the computation burden. Hence, the feasibility of the presented NURBS preprocessing method is demonstrated.

Look-ahead feedrate scheduling algorithm validation

A WM-shape NURBS curve with both high and low curvature zones is employed to validate the proposed look-ahead feedrate scheduling algorithm. The NURBS parameters of the curve are given as follows:

Order p: 2;

Knot vector ${U_{i}}$ : {0,0,0,0.15,0.3,0.5,0.7,0.85,1,1,1};

Control points ${P_{i}}$ : {[0,0] [8,10] [15,5] [17,–5] [25,15] [30,–5] [33,0] [40,–10]};

Weights ${w_{i}}$ : {1, 4, 2, 20, 4.5, 3.5, 3.5, 1}.

The parameters employed for the test are illustrated in Table 3, and they are artificially set according to commonly used values. Note that the feedrate and acceleration limits of each axis are set as different values for verification of the proposed approach. The command feedrate is set to $70 mm / s$ , which is higher than the axial velocity limits, so that the maximum axial feedrate constraint could take effect.

Table 3.

Parameters used for the simulation test.

Symbol	Parameter	Value
T	Interpolation period	$2 ms$
F	Command feedrate	$70 mm / s$
$V_{x}$	X-axis feedrate limit	$65 mm / s$
$V_{y}$	Y-axis feedrate limit	$50 mm / s$
$A_{x}$	X-axis acceleration limit	$700 mm / s^{2}$
$A_{y}$	Y-axis acceleration limit	$600 mm / s^{2}$
$J_{\max}$	Tangential jerk limitation	$18, 000 mm / s^{3}$
$δ_{\max}$	Chord error limitation	$1 μ m$

The WM-shape curve is shown in Figure 13(a). The feedrate constraints are shown in Figure 13(b). By employing the proposed preprocessing method, 15 critical points are found and the curve is divided into 16 blocks. Some critical points are very close and their tolerant feedrate values change abruptly. The short blocks between these critical points are non-schedulable. By employing the windowing look-ahead and feedrate correction method, a smooth feedrate profile is generated without violating any constraints, as shown in Figure 13(b).

Figure 13.

WM-shape curve look-ahead feedrate scheduling test: (a) geometry of the WM-shape curve, (b) feedrate limits and scheduled feedrate profile, (c) X-axis feedrate, (d) Y-axis feedrate, (e) X-axis acceleration, (f) Y-axis acceleration, (g) tangential acceleration, and (h) tangential jerk.

The axial feedrate and acceleration profiles of X-axis and Y-axis are shown in Figure 13(c)–(f), respectively. The tangential acceleration and jerk profiles are shown in Figure 13(g) and (h). All the actual values in terms of axial feedrate, axial acceleration, and tangential jerk are constrained within the set limitations.

Figure 14(a) shows the feedrate profile with respect to time. As can be seen, a short sine-curve feedrate profile is scheduled in order to eliminate the terminal error at the end of the NURBS curve. As shown in Figure 14(b), the feedrate is decelerated to zero at point A. However, the end of the curve is not reached yet. With the compensation feedrate profile applied, extra interpolation points are generated until the end of the curve.

Figure 14.

Terminal error compensation: (a) Feedrate profile and (b) interpolation points.

The chord error of each interpolation point is also estimated, as shown in Figure 15(a) and (b). Using the proposed SLW method, the chord error profile is efficiently limited within the preset limitation $1 μ m$ .

Figure 15.

Chord error profile: (a) chord error generated with constant interpolation feedrate, $F = 70 mm / s$ , and (b) chord error generated with SLW smooth feedrate.

In addition, the parameter compensation method proposed by Yeh and Hsu²² is utilized to reduce the feedrate fluctuation, as shown in Figure 16. After parameter compensation, the maximum feedrate fluctuation is reduced from 6.691% to 0.035%.

Figure 16.

Feedrate fluctuations of different methods for the WM-curve test: (a) first-order Taylor expansion interpolation and (b) parameter compensation interpolation.

Real-time performance evaluation

To verify that the proposed preprocessing, feedrate scheduling algorithm, and real-time interpolation can be run online simultaneously, both the trident curve and the WM-shape curve are tested to evaluate the computational capability. Simulation results are listed in Table 4.

Table 4.

Execution time evaluation of key algorithms $(μ s)$ .

Algorithm	Trident curve	WM-shape curve
NC interpreter	132	140
Pre-interpolation	19	17
Adaptive Simpson’s rule	525	478
Look-ahead feedrate correction	3	3
Feedrate scheduling	2	2
NURBS interpolation	2	2

NC: Numerical Control; NURBS: non-uniform rational B-splines.

Take the trident curve for example. The length of a look-ahead window is $4.849 mm$ ; it takes $69 ms$ to travel the length with maximum feedrate, $70 mm / s$ . There are 43 pre-interpolation points in a window averagely. It takes about $817 μ s$ to fill a look-ahead window with reference points, and $530 μ s$ (including Adaptive Simpson’s method, look-ahead feedrate correction, and feedrate scheduling algorithms) to generate a feasible feedrate profile for the look-ahead window. The total look-ahead feedrate planning time is $1347 μ s$ , which is far shorter than the minimum machining time $(69 ms)$ . Therefore, the proposed feedrate scheduling algorithm is able to run online simultaneously with real-time NURBS interpolation. In practical application, the next look-ahead window is planned during the machining time of current window.

As shown in Table 4, the Adaptive Simpson’s method takes a lot of execution time with a tight tolerance adopted. However, with the terminal error compensation algorithm applied, there is no need to evaluate the length of an NURBS block accurately. Hence, a loose length tolerance could be adopted to avoid unnecessary computing burden.

Analyses and comparisons

The butterfly-shaped curve is widely adopted in many researches, and some comparison data between the dynamics-based interpolation algorithms with look-ahead (DBLA) method⁶ and the NURBS interpolator with feedrate scheduling (NIFS) method²⁰ are provided in Liu et al.²⁰ In order to further evaluate the proposed SLW method via comparing with DBLA and NIFS method, the butterfly curve is chosen as the test case in this study.

The geometry model and critical points of the butterfly curve are shown in Figure 17. The feedrate profile generated by SLW algorithm is shown in Figure 18. The scheduled feedrate profile of SLW is a little different with DBLA and NIFS, because different feedrate limitations are considered. Axial velocity and axial acceleration are constrained in this study.

Figure 17.

Geometry model of the butterfly curve.

Figure 18.

Feedrate, chord error, and feedrate fluctuation profiles generated by SLW.

Some statistical comparisons between SLW and the two methods are shown in Table 5. Since each axis of the machine tool has different kinematic performance in this study, simply using the geometrical curvature of the tool path is not an adequate quantity to identify the “critical points.” With axial velocity/acceleration limits considered, more critical points are identified by the SLW method than DBLA and NIFS. As a result, the scheduled feedrate around the extra critical points is reduced, and it takes more machining time.

Table 5.

Statistical comparisons.

	DBLA	NIFS	SLW
Number of reference points	4277	777	3892
Number of critical points	19	19	30
Deviation of critical points	0.1691%	0.3685%	0.3676%
Maximum chord error $(mm)$	0.3305	0.3759	0.3564
Number of interpolating points	4593	4477	6379
Machining time $(s)$	4.593	4.477	6.379
Feedrate fluctuation	–	0.5166%	0.0196%

DBLA : dynamics-based interpolation algorithms with look-ahead method; NIFS: NURBS interpolator with feedrate scheduling; NURBS: non-uniform rational B-splines; SLW: sliding look-ahead window.

The NIFS method generates less reference points and consumes less computational time in the preprocessing stage using the interval subdivision algorithm. However, the interval subdivision algorithm causes the whole curve to be preprocessed and scheduled at once. The feedrate profile is fixed after generation, and it needs to be rescheduled when a machining pause operation is requested. With the SLW algorithm, the look-ahead length is short; it is easier to response to machining “PAUSE” or “STOP” commands by appending zero velocity reference point to the latest look-ahead window.

Machining trial

To further assess the feasibility of the proposed feedrate scheduling method, a machining experiment is carried out on a three-axis milling machine. The machine tool is controlled using the LinuxCNC, which is an open source CNC system. LinuxCNC is extended to support Industrial Real-Time Ethernet protocol EtherCAT, which is supported by the servo drivers on the milling machine. The proposed NURBS preprocessing method and windowing look-ahead feedrate scheduling method are developed as a real-time component of LinuxCNC and run cyclically in the kernel space. The interpolated position commands are transferred to the servo drivers through EtherCAT bus. In order to guarantee that the interpolation algorithm can be completed in real time, the computation time for calculating each reference point and the feedrate at each point are recorded. It is found that the maximum calculation time is $26 μ s$ , which is far shorter than the interpolation period. The machined workpiece is shown in Figure 19.

Figure 19.

Machining trial: (a) the milling machine and (b) the machined workpiece.

Conclusion

In this article, a real-time NURBS feedrate scheduling method with chord error, axial feedrate, acceleration, and jerk limitations is proposed to make balance between the machining efficiency, precision, and computational complexity. This method contains an online preprocessor and a look-ahead feedrate profile generator. In the preprocessing stage, a local fine pre-interpolation method is developed to accurately estimate the feedrate limitation profile by reducing pre-interpolation feedrate in feedrate-sensitive regions. After preprocessing, acceleration/deceleration start/end point parameters and the corresponding tolerant feedrate values are obtained and stored in the buffer. A windowed look-ahead feedrate scheduling method is proposed to generate smooth feedrate profile for the buffered NURBS segments. A smooth feedrate profile could be generated with sufficient look-ahead travel length in the buffer, which enables that the preprocessing and feedrate planning to be performed progressively in real-time domain. Simulation and experimental results validate the feasibility and advantages of the proposed method. The presented method is highly applicable in open CNCs because the proposed algorithms are computationally efficient and robust as verified in the experimental results.

In this work, only chord error, axial feedrate, acceleration, and jerk limitations are considered. To further improve the machining precision, the feedrate scheduling method with contour-error and drive constraints should be studied in future research.

Footnotes

Acknowledgements

The authors wish to thank the anonymous reviewers for their comments, which led to improvements of this paper.

Handling Editor: Tatsushi Nishi

Declaration of conflicting interests

The author(s) declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Funding

The author(s) disclosed receipt of the following financial support for the research, authorship, and/or publication of this article: This work is supported by the National Natural Science Foundation of China (51805116) and the National Science and Technology Major Project of China (2013ZX04013-011-09).

ORCID iD

Jiankang Liu

References

Piegl

Tiller

The NURBS book. Berlin; Heidelberg: Springer, 1997.

Emami

Arezoo

A look-ahead command generator with control over trajectory and chord error for NURBS curve with unknown arc length. Comput Aided Design 2010; 42: 625–632.

Jia

Song

et al . A NURBS interpolator with constant speed at feedrate-sensitive regions under drive and contour-error constraints. Int J Mach Tool Manu 2017; 116: 1–17.

Jia

Song

et al . A review of contouring-error reduction method in multi-axis CNC machining. Int J Mach Tool Manu 2018; 125: 34–54.

Yong

Narayanaswami

A parametric interpolator with confined chord errors, acceleration and deceleration for NC machining. Comput Aided Design 2003; 35: 1249–1259.

Lin

Tsai

Yau

HT.

Development of a dynamics-based NURBS interpolator with real-time look-ahead algorithm. Int J Mach Tool Manu 2007; 47: 2246–2262.

Liu

Ahmad

Yamazaki

et al . Adaptive interpolation scheme for NURBS curves with the integration of machining dynamics. Int J Mach Tool Manu 2005; 45: 433–444.

Tsai

Nien

Yau

HT.

Development of an integrated look-ahead dynamics-based NURBS interpolator for high precision machinery. Comput Aided Design 2008; 40: 554–566.

Sun

Zhao

Bao

et al . A novel adaptive-feedrate interpolation method for NURBS tool path with drive constraints. Int J Mach Tool Manu 2014; 77: 74–81.

10.

Tikhon

Lee

et al . NURBS interpolator for constant material removal rate in open NC machine tools. Int J Mach Tool Manu 2004; 44: 237–245.

11.

Erkorkmaz

Altintas

High speed CNC system design. Part I: jerk limited trajectory generation and quintic spline interpolation. Int J Mach Tool Manu 2001; 41: 1323–1345.

12.

Nam

Yang

MY.

A study on a generalized parametric interpolator with real-time jerk-limited acceleration. Comput Aided Design 2004; 36: 27–36.

13.

Chen

Yeh

Sun

JT.

An S-curve acceleration/deceleration design for CNC machine tools using quintic feedrate function. Comput Aided Design Appl 2011; 8: 583–592.

14.

Wang

Gai

Sun

et al . Research on quartic polynomial velocity planning algorithm for high-quality machining. China Mech Eng 2014; 25: 636–641.

15.

Lee

Lin

Pan

et al . The feedrate scheduling of NURBS interpolator for CNC machine tools. Comput Aided Design 2011; 43: 612–628.

16.

Wang

Yang

Gai

et al . Design of trigonometric velocity scheduling algorithm based on pre-interpolation and look-ahead interpolation. Int J Mach Tool Manu 2015; 96: 94–105.

17.

Zhong

Luo

Chang

et al . A real-time interpolator for parametric curves. Int J Mach Tool Manu 2018; 125: 133–145.

18.

Erkorkmaz

Chen

Zhao

et al . Linear programming and windowing based feedrate optimization for spline toolpaths. CIRP Ann: Manuf Techn 2017; 66: 393–396.

19.

Lei

Sung

Lin

et al . Fast real-time NURBS path interpolation for CNC machine tools. Int J Mach Tool Manu 2007; 47: 1530–1541.

20.

Liu

Huang

Yin

et al . Development and implementation of a NURBS interpolator with smooth feedrate scheduling for CNC machine tools. Int J Mach Tool Manu 2014; 87: 1–15.

21.

Heng

Erkorkmaz

Design of a NURBS interpolator with minimal feed fluctuation and continuous feed modulation capability. Int J Mach Tool Manu 2010; 50: 281–293.

22.

Yeh

Hsu

PL.

The speed-controlled interpolator for machining parametric curves. Comput Aided Design 1999; 31: 349–357.

Sliding look-ahead window-based real-time feedrate planning for non-uniform rational B-splines curves

Abstract

Keywords

Introduction

Development of the interpolation scheme

Definitions of NURBS curve

Interpolation of NURBS curve

Curvature and chord error estimation

Real-time feedrate scheduling scheme

Feedrate scheduling algorithm

Real-time NURBS curve preprocessing

Feedrate limit

Acceleration limit

Local fine preprocessing method

Jerk-limited trigonometric velocity profile

Feedrate profile generation for an NURBS block

Windowed look-ahead feedrate scheduling method

Feedrate correction for non-schedulable blocks

Terminal error compensation of NURBS blocks

Simulation and experimental results

Pre-processing method validation

Look-ahead feedrate scheduling algorithm validation

Real-time performance evaluation

Analyses and comparisons

Machining trial

Conclusion

Footnotes

Acknowledgements

Declaration of conflicting interests

Funding

ORCID iD

References