Closed-loop form quantization algorithm with bounded...

Advanced Robotics, Vol. 18, No. 9, pp. 927–942 (2004) VSP and Robotics Society of Japan 2004.Also available online - www.vsppub.com

Full paper

Closed-loop form quantization algorithm with boundedaccumulative error

KYOUNG CHUL KOH 1, BYOUNG WOOK CHOI 2,∗, MOON HO KANG 2

and BOK SHIN AHN 3

1 Division of Mechanical Engineering, Sun Moon University, Kalsanri 100, Asanshi,Chungnam-do 336-840, South Korea

2 Department of Control and Measurement Engineering, Sun Moon University, Kalsanri 100,Asanshi, Chungnam-do 336-840, South Korea

3 P&C Technologies Co., Ltd., Dongaworld Plazar 603, 1048-2, Hogyedong, Dongangu, Anyangsi,Kyongki 431-080, South Korea

Received 2 April 2004; accepted 23 April 2004

Abstract—This paper proposes a closed-loop form quantization algorithm that guarantees theboundness of accumulative error. The algorithm is particularly useful for mobile robot navigationthat is usually implemented on embedded systems. If the wheel command of the mobile robot isgiven by velocity or positional increments at every control instant that are quantized due to the finiteword length of the controller’s CPU, the quantization error accumulates to produce large positionerror. Such an error is critical for wheeled mobile robots or autonomous vehicles with non-holonomicconstraints. To solve this problem, a non-error accumulative quantization algorithm with a closed-loop form is presented. We can extend it to a generalized form corresponding to the nth-orderaccumulation. The boundness of the accumulative quantization error is proven via mathematicprocesses and verified by a series of computer simulations. The proposed method is effective toaccurately control the autonomous mobile robot, particularly with embedded systems.

Keywords: Accumulative quantization error; embedded control systems; microprocessor applications;velocity control; mobile robot.

1. INTRODUCTION

A large amount of literature exists about motion planning for mobile robots [1–3].Real vehicles moved by wheels on the ground are subject to non-holonomicconstraints [4, 5]. In motion planning, the simple truncation in numeric operationscauses infinite accumulative error that is particularly critical for mobile robotnavigation [6, 7]. The quantization usually comes from the finite word length of the

∗To whom correspondence should be addressed. E-mail: [email protected]

928 K. C. Koh et al.

CPU or limited sensor resolution such as in rotary encoders. The quantization errormay be tolerable in the case of directly using them. However, since the quantizedvalues are velocity commands or incremental position commands, the accumulativeerror introduces large positional error that restricts path tracking of a planned path.

It is also important for embedded real-time systems in which the integer computa-tion is usually performed [8, 9]. The hierarchical control structure of mobile robotsrequires an accumulative quantization error reduction algorithm. In previous stud-ies, issues on quantization error reduction had been presented in image processingto reduce image distortion [10] and were not focused on control engineering to re-duce such an accumulative quantization error. In a previous study [11], the overallrequirements for mobile robot architecture are outlined in terms of control, modular-ity, software engineering and run-time performance. Traditionally the architecturesof the mobile robot were of a hierarchical form [12] in which a high-rate servocontrol loop is performed in a lower level controller and a low-rate path trackingcontroller is performed in a higher-level controller. The wheel velocity commandsare precisely computed by the path-tracking controller based on floating point op-erations and transferred to the wheel servo controller in which quantization of thecommands occurs due the finite word length of the embedded microprocessor.

To reduce the accumulative error that results from quantization, we propose anew simple quantization algorithm with a closed-loop form. After all, it grantsus more advantages than just the use of a floating command. Basically, sincethe algorithm is based on the closed-loop form, the numerical overflow problemin internal computation can be completely eliminated. We can also extend it toa generalized form corresponding up to the nth-order command. The boundnessof the accumulative error is mathematically proven. To show the validity of thealgorithm, a series of computer simulations are performed and the results showthat the presented algorithms work well. The remainder of the paper is organizedas follows. In Section 2, we address the problem statement and the proposedquantization algorithm eliminating accumulative error. In Section 3, we extend thequantization algorithm to the second-order form and generalize it to the nth-orderform. In Section 4, we report the simulation results. Finally, we conclude the paperin Section 5.

2. ACCUMULATIVE QUANTIZATION ERROR REDUCTION ALGORITHM

Let a conventional quantization function Q0(·) be:

x0 = Q0(x), x0 � x < x0 + δ, (1)

where x0 is a quantized value and δ is a quantization unit. The quantization erroris bounded by δ. For path-tracking control in a wheeled mobile robot navigationsystem, let us assume the wheel velocity command v(k) at every control instantis computed and its quantized value is transferred to the wheel servo controller inwhich a velocity control loop is performed for the quantized velocity command.

Closed-loop form quantization algorithm 929

Figure 1. Q1(·) algorithm of the open-loop form.

At this instant, the position error occurs due to the quantization process. We canimagine that the small errors in the wheel velocity control cause large positionalerror due to accumulative error that is particularly critical for non-holonomic mobilerobots such as wheeled vehicles. Now, we investigate the error characteristic ofthe conventional quantization Q0(·). Assuming no quantization process happens,the wheel position can be computed p(k) at the kth control instant by simpleaccumulation of the velocity command v(k) as follows:

p(k) = p(k − 1) + v(k). (2)

Now, we consider the velocity command. The accumulative error due to thequantization of Q0(·) goes to infinity as the number of iteration increases:

limk→∞

(p(k) −

k∑n=0

Q0(v(n))

)

= limk→∞

k∑n=0

((v(n) − Q0(v(n))) < limk→∞ kδ = ∞. (3)

In order to prevent the infinity problem of the conventional quantization algorithmof Q0(·), let us consider a new quantization algorithm ofQ1(·). At each step, v(k)

is quantized by the following quantization function:

v1(k) = Q0(p(k)) − Q0(p(k − 1)) ≡ Q1(v(k)). (4)

Figure 1 shows (4) as a block diagram in a digital control system. Using (2) and (4),the accumulative error due to the quantization of Fig. 1 is bounded:

limk→∞

(p(k) −

k∑n=0

Q1(v(n))

)= lim

k→∞(p(k) − Q0(p(k))) < δ. (5)

However, the open-loop form of Q1(·) causes the computational overflow whichmay happen as the number of sequences increases since p(k) is computed by (2).

To solve this overflow problem of internal computation, we convert Q1(·) into theclosed-loop form as follows:

v1(k) = Q0(z(k)), (6)

z(k) = z(k − 1) + v(k) − Q0(z(k − 1)). (7)

This algorithm can be described as the control block diagram in Fig. 2. Theequivalence of the closed-loop form ofQ1(·) given by (6) and (7) to the open-loop


Figure 2. Q1(·) algorithm of the closed-loop form.

form of Q1(·) of (4) can be shown by the following mathematical manipulations.First, we can rewrite (7) as a summation form:

z(k) =k∑

n=0

v(n) −k∑

n=1

Q0(z(n − 1))

= p(k) −k∑

n=1

Q0(z(n − 1)). (8)

The Q0(·) quantization of (8) yields:

Q0(z(k)) = Q0(p(k)) − Q0

(k∑

n=1

Q0(z(n − 1))

)

= Q0(p(k)) −k∑

n=1

Q0(z(n − 1)), (9)

since Q0(Q0(z(k)) = Q0(z(k)). Then, (9) can be rewritten as:

Q0(p(k)) = Q0(z(k)) +k∑

n=1

Q0(z(n − 1))

=k∑

n=0

Q0(z(n))

=k∑

n=0

v1(n). (10)

Using (10), we can easily derive (4) by:

Q0(p(k)) − Q0(p(k − 1)) = v1(k) ≡ Q1(v(k)).

Thus, the closed-loop form of the Q1(·) algorithm given by (6) and (7) is equivalentto the open-loop form of Q1(·), and we can show that the internal variable z(k) of(7) is bounded by:

z(k) − v(k) = z(k − 1) − Q0(z(k − 1)) < δ. (11)


Therefore, we can solve the overflow problem in computation of (4) since z(k) in(7) is bounded within v(k) + δ from (11) and the boundness of accumulative erroris proven by verifying the equivalence of the closed form to the open-loop formof Q1(·). This is a feasible quantization algorithm in the embedded digital controlsystem to reduce the accumulative error caused by truncation.

3. GENERALIZED QUANTIZATION ERROR REDUCTION ALGORITHM

When acceleration is given as a control command in motion planning, we shouldconsider a double accumulative error effect in using the quantization algorithm.First of all, let us examine the double accumulative error characteristic of Q1(·).The quantization error of Q1(·) is bounded by the quantization value as:

x1 = Q1(x), |x − Q1(x)| < δ, (12)

where x1 is a natural number and δ is the quantization unit. For motion planning ina digital control system, the acceleration command a(k) at every control instant isdouble-accumulated as follows:

v(k) = v(k − 1) + a(k), (13)

p(k) = p(k − 1) + v(k). (14)

Then, the double accumulative error of the quantization of Q1(·), where Q1(·) is theclosed-loop form of (6) and (7), goes to infinity as the number of iteration increaseas follows:

limk→∞

(p(k) −

k∑n=0

n∑m=0

Q1(a(m))

)= lim

k→∞

k∑n=o

(v(n) − Q0(v(n))) < limk→∞ kδ = ∞,

(15)since

∑nm=0 Q1(a(m)) = Q0(v(n)) by using (4).

To solve this double accumulative infinity problem of the quantization algorithmof the closed-loop form of Q1(·), let us consider the double accumulative errorreduction algorithm of Q2(·). By extending Q1(·), we can easily make the doubleaccumulative error reduction algorithm Q2(·).

Double accumulative error reduction algorithm. At each step, a(k) is quantizedby the following quantization function Q2(·):

a2(k) = Q1(v(k)) − Q1(v(k − 1)) ≡ Q2(a(k)). (16)


Figure 3. Q2(·) algorithm of the open-loop form.

Figure 4. Q2(·) algorithm of the closed-loop form.

Figure 3 shows (16) as a block diagram in the digital control system. The doubleaccumulative error due to the quantization of Fig. 3 can be written by using (16):

limk→∞

(p(k) −

k∑n=0

n∑m=0

Q2(a(m))

)= lim

k→∞

(p(k) −

k∑n=o

Q1(v(n))

). (17)

Equation (17) yields (18) since∑k

n=0 Q1(v(n)) = Q0(p(k)) using (4):

limk→∞

(p(k) −

k∑n=0

n∑m=0

Q2(a(m))

)= lim

k→∞(p(k) − Q0(p(k)) < δ. (18)

Therefore, the double accumulative error of Q2(·) is bounded by δ regardlessof iteration number, but computational overflow may happen as the number ofsequence increases since v(k) is computed by (13).

To solve this overflow problem of the internal value, we change Q2(·) of (16) intothe closed-loop form structure as follows:

a2(k) = Q1(y(k)), (19)

y(k) = y(k − 1) + a(k) − Q1(y(k − 1)), (20)

where Q1(·) is given as the closed-loop form of (6) and (7). Including the innerblock of Fig. 3, the closed-loop form of Q2(·) algorithm can be descibed in digitalcontrol block diagram as Fig. 4. This is just equivalent to the open-loop form ofQ2(·) while it has the bounded double accumulative error characteristic.


The equivalence of the closed-loop form quantization given by (19) and (20) tothe open-loop form of Q2(·) of (16) can be verified by the following mathematicalmanipulations. First, we can rewrite (20) as a summation form:

y(k) =k∑

n=0

a(n) −k∑

n=1

Q1(y(n − 1)). (21)

Q1(·) quantization of (21) is described as:

Q1(y(k)) = Q1

(k∑

n=0

a(n) −k∑

n=1

Q1(y(n − 1))

)

= Q1(v(k)) −k∑

n=1

Q1(y(n − 1)). (22)

Since Q1(Q1(y(k)) = Q1(y(k)), of which the proof is apparent and henceomitted here, from (19) and (22), Q1(v(k)) can be represented as:

Q1(v(k)) = Q1(y(k)) +k∑

n=0

Q1(y(n − 1))

=k∑

n=0

Q1(y(n))

=k∑

n=0

Q2(a(n)). (23)

Using (23), we can easily derive the following equations of (16) as:

Q1(v(k)) − Q1(v(k − 1)) = Q2(a(k)) ≡ a2(k).

The algorithm given by (19) and (20) has the closed-loop form, and the error isbounded within the quantization unit since it is equivalent to the open-loop form ofQ2(·) of (16). By following equations, we can easily show that internal variabley(k) of (20) is bounded:

y(k) − a(k) = y(k − 1) − Q1(y(k − 1)),

|y(k) − a(k)| = |y(k − 1) − Q1(y(k − 1))| < δ. (24)

Therefore, the overflow problem in the computation is solved since |y(k)| isbounded within |a(k)|+δ. It is a feasible quantization algorithm for the accelerationcontrol system. By using the feature of the internal recursive structure, one caneasily extend this algorithm to the nth-order quantization algorithm Qn(·) as:

xn(k) = Qn−1(y(k)), (25)


y(k) = y(k − 1) + x(k) − Qn−1(y(k − 1)), (26)

which reveals the nth-order bounded accumulative error.

4. COMPUTER SIMULATION

To investigate the performance of the proposed quantization algorithm, a seriesof computer simulations were performed for an acceleration profile of a mobilerobot. In mobile robot navigation, the wheel acceleration command is computedby floating-point operation in the main computer and transferred to the wheel servocontroller after the quantization process [7]. To avoid slippage between the wheeland floor, the acceleration profile is designed in a sinusoidal form by consideringthe jerk continuity as shown in Fig. 5.

Let us assume the acceleration command given in Fig. 5 is quantized by Q0(·) of(1) as shown in Fig. 6.

Figure 7 shows that the quantization of the acceleration command by Q0(·) of (1)causes a large velocity error during the accumulation of the quantized values.

At this time, let us assume that the acceleration command given in Fig. 5 isquantized by the closed-loop form of Q1(·) of (6) and (7) as in Fig. 8. Thesimulation results of the open-loop form of Q1(·) of (4) is not shown since theresults are exactly same as with the closed-loop form except that the open-loopform has computational overflow in the internal value.

Figure 5. Acceleration profile for a wheeled mobile robot.


Figure 6. Acceleration profile quantized by Q0(·) of (1).

Figure 7. Velocity profile generated from the acceleration profile quantized by Q0(·) of (1).


Figure 8. Acceleration profile quantized by the closed-loop form of Q1(·).

Figure 9 shows the velocity profile by accumulating the acceleration profilequantized by the closed-loop form of Q1(·) of (6) and (7). The velocity profileis the first-order accumulation of the acceleration command and it has no error.

In Fig. 10, we depict errors between the velocity generated by accumulating theaccelerations quantized by the closed-loop form of Q1(·) and the velocity generatedby accumulating the original acceleration command. Therefore, the velocity erroris bounded.

Even though the velocity error is bounded as shown in Fig. 10, it can also producea large position error as predicted by (15) in Section 3. Figure 11 shows the positionerror due to the double accumulative infinity problem of the quantization algorithmof Q1(·) of (6) and (7).

Now, let us observe the simulation result of applying the Q2(·) algorithm of (19)and (20) to the quantization of acceleration command. Figure 12 is the accelerationprofile after applying the Q2(·) algorithm.

The velocity profile by accumulating the acceleration profile quantized by Q2(·)of (19) and (20) is described in Fig. 13. The velocity command obtained by thequantized acceleration command reveals bounded error.

Figure 14 shows errors between the velocity generated by accumulating theacceleration quantized by Q2(·) of (19) and (20) in Fig. 12, and the velocitygenerated by accumulating the unquantized acceleration.


Figure 9. Velocity profile by accumulating the acceleration profile quantized by the closed-loop formof Q1(·).

Figure 10. Velocity error due to the quantized acceleration by the closed-loop form of Q1(·).


Figure 11. Position error due to the quantization of acceleration in the closed-loop form of Q1(·).

Figure 12. Acceleration profile quantized by Q2(·).


Figure 13. Velocity profile by accumulating the acceleration profile quantized by Q2(·).

Figure 14. Velocity error due to the quantized acceleration by Q2(·) of (19) and (20).


Figure 15. Position error due to the quantization acceleration by Q2(·) of (19) and (20).

Figure 16. Position profiles obtained from accumulating the accelerations quantized by Q0(·) andQ2(·), respectively.


As predicted by (18) in Section 3, the quantization of Q2(·) has the boundeddouble accumulative error characteristic. Figure 15 shows the boundness of thepositional error due to quantization of Q2(·).

Figure 16 shows the comparative position profiles obtained from accumulatingthe accelerations quantized by Q0(·) and Q2(·), respectively. Therefore, weachieve the second-order quantization algorithm without accumulative error so thatthe commands generated from the Q2(·) quantization algorithm overlap with theoriginal commands in Fig. 16.

5. CONCLUDING REMARKS

We have proposed a quantization error reduction algorithm that is practicallymeaningful in a control system implemented by embedded systems. Since theproposed algorithm has a closed-loop form, it can solve the internal overflowproblem. The accumulative error boundness of the proposed algorithm is provenvia some mathematical manipulations. We can also generalize the quantizationalgorithm by showing that the extension of the algorithm to the nth-order guaranteesthe error boundness of the nth-order accumulation. To show effectiveness ofthe proposed algorithm, a series of computer simulations were performed formotion planning in which an acceleration profile is given by trapezoidal form.The simulation results confirm that the algorithm works well. We will presentexperimental results to confirm the efficiency of the algorithm in future work.

REFERENCES

1. J. C. Latombe, Robot Motion Planning. Kluwer, Dordrecht (1991).2. Y. K. Hwang and N. Ahuja, Gross motion planning — a survey, ACM Comput. Surv. 24, 219–291

(1992).3. H. Weber, A motion planning and execution system for mobile robots driven by stepping motors,

Robotics Autonomous Syst. 33, 207–221 (2000).4. I. Kolmanvsky and N. H. McClamroch, Developments in nonholonomic control problems, IEEE

Control Syst. 15, 20–36 (1995).5. Z. Li and J. F. Canny, Nonholonomic Motion Planning. Kluwer, Dordrecht (1993).6. S. Singh and D. H. Shin, Position based path tracking for wheeled mobile robots, in: Proc. IEEE

Int. Workshop on Robotics and Systems, Osaka (1989).7. K. C. Koh and H. S. Cho, A path tracking control system for autonomous mobile robots: an

experimental investigation, Mechatronics 4, 799–820 (1994).8. Z. Gu and K. G. Shin, Integrated modeling and analysis of computer-based embedded control

system, in: Proc. IEEE Int. Conf. on the Engineering of Computer-Based Systems (2003).9. Dreamtech Software Team, Programming for Embedded Systems. Wiley, New York (2003).

10. C. M. Ng, V. Ng and P. L. Poon, Quantisation error reduction for reducing Q-factor JPEGrecompression, in: Proc. IFSA World Congress and 20th NAFIPS Int. Conf., Vol. 3, pp. 1460–1465 (2001).

11. A. Orevack and H. I. Christens, Evaluation of architectures for mobile robotic, AutonomousRobots 14, 33–49 (2003).


12. R. C. Arkin, Integrating behavioral, perceptual, and world knowledge in reactive navigation,Robotics Autonomous Syst. 6, 105–122 (1990).

ABOUT THE AUTHORS

Kyoung Chul Koh received the MS and PhD degrees in Mechanical Engineeringfrom the Korean Advanced Institute of Science and Technology, Korea, in 1984and 1994, respectively. Prior to his present appointment, he was a ResearchGroup Leader at the LG Institute of Technology for development industrial robotcontrollers. He is currently Professor in the Mechanical and Control Divisionat Sun Moon University, South Korea. His research interests include mobilenavigation and intelligent control.

Byoung Wook Choi received the MS and PhD degrees in Electrical Engineeringfrom the Korean Advanced Institute of Science and Technology, in 1988 and1992, respectively. His is currently a Professor in the Department of Control andMeasurement Engineering, Sun Moon University, South Korea. Previously, hewas a Principal Research Engineer in the LG R&D center for development of anelevator control system using RTOS and embedded systems design from 1992 to2000. Also he was a CEO of Embedded Web Co., Ltd. from 2001 to 2003. He haspublished textbooks on Embedded Linux. His current research interests includeembedded systems design, embedded operating systems, real-time systems andservice robots.

Moonho Kang received MS and PhD degrees in Electrical Engineering fromKorea University in 1990 and 1995. He is an Assistant Professor of theDepartment of Control and Measurement Engineering, Sun Moon University,South Korea. His research interests include intelligent control and wirelesstelemetering applications. He was a Senior Researcher at KRRI (Korea RailroadResearch Institute).

Bok-Shin Ahn received the BS, MS and PhD degrees from Seoul NationalUniversity. He is a member of the IEEE and a member of KIEE. He is the CEOof P&C Technologies Co., Ltd. Previously, he was a Principal Research Engineerin the LG R&D center. His interests include power distribution and embeddedcontrollers.

Closed-loop form quantization algorithm with bounded...

Documents

Transcript of Closed-loop form quantization algorithm with bounded...