DSP-BASED FUZZY CONTROLLERS: APPLICATION TO PARKING AN AUTONOMOUS ROBOT

I. Baturone1, F. J. Moreno-Velo1, S. Sánchez-Solano1, V. Blanco2, J. Ferruz2

1 Instituto de Microelectrónica de Sevilla - Centro Nacional de Microelectrónica

Avda. Reina Mercedes s/n, (Edif. CICA). E-41012, Sevilla, Spain

2 Dep. Ingeniería de Sistemas y Automática. E.S.Ingenieros. Camino de los Descubrimientos s/n. 41092, Sevilla, Spain

Proc. XIX Conference on Design of Circuits and Integrated Systems (DCIS 2004),

pp. 133-138, Bordeaux, November 24-26, 2004.

This material is presented to ensure timely dissemination of scholarly and technical work. Copyright and all rights therein are retained by authors or by other copyright holders. All persons copying this information are expected to adhere to the terms and constraints invoked by each author’s copyright. In most cases, these works may not be reposted without the explicit permission of the copyright holder.

Abstract—This paper describes how to design fuzzy

controllers meeting the hardware constraints of digital signal processors (DSPs). Fuzzy controllers are used in many applications because of their rapid design by translating heuristic knowledge, robustness against perturbations, and smoothness in the control action. However, they require parallel processing and special operators (such as fuzzification or defuzzification) which are not available at standard DSPs, thus making inefficient its direct implementation. The idea followed in this paper is to translate the fuzzy rule bases of a fuzzy controller into non fuzzy ones that can be implemented easily by using the relational and logical operators, the standard if-then conditional statements, and the addition and multiplication operators available at a DSP. This is done by using hierarchical structures and adequate membership functions, connective operators, and inference methods. The parking problem of an autonomous robot is described to illustrate this design process. Experimental results show the efficiency of the designed fuzzy controller embedded into a stand-alone card based on a fixed-point DSP from Texas Instruments.

Index Terms— Fuzzy control, DSPs, embedded controllers, autonomous robots.

I. INTRODUCTION ESIGN and implementation of a fuzzy controller obviously depends on the requirements of the

application towards which it is addressed. Four require-ments are particularly relevant: the flexibility in the design (any kind of membership function and fuzzy operators, a large number of rules, etc.), the time available for rule processing, the size it can occupy, and the power it can consume.

In the application field of autonomous mobile robots

Manuscript received April 12, 2004. This work was supported in part by the Spanish CICYT Projects DPI2002-04401 and TIC2001-1726.

I. Baturone is with the Instituto de Microelectrónica de Sevilla, Centro Nacional de Microelectrónica (IMSE-CNM), Sevilla, SPAIN (corresponding author to provide phone: +34-955-056-666; fax: +34-955-056-686; e-mail: lumi@imse.cnm.es).

F. J. Moreno Velo is with the Instituto de Microelectrónica de Sevilla, Centro Nacional de Microelectrónica (IMSE-CNM), Sevilla, SPAIN (e-mail: velo@imse.cnm.es).

S. Sánchez Solano is with the Instituto de Microelectrónica de Sevilla, Centro Nacional de Microelectrónica (IMSE-CNM), Sevilla, SPAIN (e-mail: santiago@imse.cnm.es).

V. Blanco is with the Departamento de Ingeniería de Sistemas y Automática, Universidad de Sevilla, Sevilla, SPAIN (email: vmblanco@cartuja.us.es).

J. Ferruz is with the Departamento de Ingeniería de Sistemas y Automática, Universidad de Sevilla, Sevilla, SPAIN (email: ferruz@cartuja.us.es).

(capable of performing tasks without the intervention of human operators) built-in machine intelligence and an on-board control system are required. Fuzzy logic has been employed widely in autonomous robots to provide intelligence in solving many tasks, in particular the task of parking, which is the one addressed in this paper [1-3]. The trend in many autonomous robots (such as planetary exploration vehicles, unmanned aerial vehicles, microrobots, etc.) is that the on-board control system is restricted to a small size, light weight, and low power consumption. This means the need for embedded controllers capable of real-time operation because, unlike general-purpose computers, embedded systems are designed and optimized to provide specific functionality. An embedded system may be implemented with a number of technologies: (a) embedded software on off-the-shelf components: general-purpose (microprocessors) or specific processors (microcontrollers and digital signal processors or DSPs), (b) programmable logic (such as FPGAs), and (c) full-custom or semi-custom ASICs. This paper is focused on DSP-based embedded fuzzy controllers.

DSPs are designed specifically for implementing real-time signal processing operations, like convolutions or correlations, but are not efficient for performing certain basic operations of fuzzy inference methods, like minimum, maximum or defuzzification. One solution to reduce this limitation is to modify or extend the DSP so as to be adequate for fuzzy operations. The other solution is to design the fuzzy controller so as to be adequate for the DSP capabilities. This paper is focused on the second solution and, hence, three issues are pursued in the design of the fuzzy controller: hierarchical structures (to reduce the number of rules and, therefore, the number of operations to be demanded in parallel), exploitation of symmetry (to reduce the number of data and operations to be carried out), and the choice of membership functions, connective operators, and inference methods suited to the DSP central processing unit.

This paper is structured as follows. Section II summarizes the features of the DSP platform that controls the autonomous robot ROMEO 4R, a car-like vehicle designed and built at the Escuela Superior de Ingenieros de Sevilla [4]. Section III describes the parking problem addressed and its geometric, kinematic, and dynamic constraints. The design of an efficient fuzzy controller meeting the hardware constraints imposed by the embedded platform is addressed in Section IV. Several experimental results of diagonal parking maneuvers are included in Section V to illustrate

DSP-based Fuzzy Controllers: Application to Parking an Autonomous Robot

Iluminada Baturone, Francisco J. Moreno-Velo, Santiago Sánchez-Solano, Víctor Blanco, and Joaquín Ferruz

D

the efficiency and robustness of the designed controller. Finally, conclusions are given in Section VI.

II. FEATURES OF THE DSP PLATFORM ROMEO 4R is an electrical vehicle provided with a set of

sensors and actuators that make it capable of autonomous navigation (Fig. 1). The information collected by the sensors and that required by the actuators is centralized by a stand-alone card from Spectrum Digital (the LF2407 EVM) [5]. This card, whose block diagram is shown in Fig. 2, is shipped with: (1) a TMS320LF2407 DSP from Texas Instruments (where all the operations required by the low-level control algorithms are implemented, as well as the high-level fuzzy controller described herein), (2) LF2407 external memory (128 K SRAM), (3) Digital to Analog Interface (four 12-bit D/A channels, which are used to address the traction and steering motor control cards), (4) SPI logging interface (adapted to receive information from a gyroscope), (5) expansion interface (used to receive information from traction and steering encoders), (6) serial interface (used to communication with an external PC which defines the task to be performed by the robot and collects experimental data or any possible error message), (7) JTAG interface (used to load, execute and debug the programs into the DSP), (8) LEDs and switches, and (9) CAN interface (not used currently).

The TMS320LF2407 is a fixed-point DSP of the TMS320 family which combines onto a single chip the real-time processing capability of a DSP core with the peripherals of a microcontroller (two event-manager modules, a 10-bit analog-to-digital converter, etc.) so as to meet a wide range of digital motor control and embedded control applications [6]. It uses a Harvard-type architecture which contains two separate memory bus structures (program and data) for allowing data and instructions to be read simultaneously. This, together with a four-deep pipeline, allows executing most instructions in a single cycle of 33ns (30 MHz), being able to reach a performance of 30 MIPS. The on chip memory includes 32 K words of 16 bits of Flash EEPROM and 2.5 K words of 16 bits of

Data/Program RAM. The central processing unit of this DSP contains: (a) a 32-bit central arithmetic logic unit (which can perform 16-bit addition and subtraction, Boolean logic operations, and bit testing, shifting, and rotating), (b) a 32-bit accumulator, (c) input and output data-scaling shifters, (d) a 16-bit x 16-bit multiplier, (e) a product-scaling shifter, and (f) data- and program-address generation logic. The fuzzy controller described herein has been designed to meet these hardware constraints.

Texas Instruments provides several tools to work with its DSPs, in particular, ANSI C compiler, assembler/linker, and the Code Composer StudioTM development environment, which allows building and debugging real-time software applications. This environment has been employed to develop and load into the DSP a software interface (programmed in C) which accesses the sensors and actuators of the robot, implements the low-level PID controllers, and manages the different tasks. Having this interface, the high-level fuzzy control algorithm is relieved of the task of synchronizing the read and write processes of the different robot devices. The designed fuzzy controller described in the following has been also loaded into the DSP by using the Code Composer Studio.

III. DESCRIPTION OF THE PARKING PROBLEM The problem addressed in this paper is the diagonal

parking of a car-like autonomous vehicle in a constrained space. Starting from any given position (x, y), and orientation (φ), the vehicle can drive forward and backward but has to arrive backward at the desired parking place at a right angle with the horizontal and to stop there. Fig. 3 shows an scheme of this problem.

In our application, the robot knows its position, orientation, and driving speed by processing the information provided by a gyroscope and several encoders in the traction wheels and in the direction. With this information, the low-level control of the vehicle applies odometry by using a simple kinematic model usually employed for car-like robot:

Fig. 2. Block diagram of the LF2407 EVM card.

Fig. 1. The autonomous robot ROMEO 4R.Fig. 1. The autonomous robot ROMEO 4R.

⎪⎩

⎪⎨

⎧

⋅=⋅=⋅=

vvyvx

γφφφ

&

&

&

)cos()sin(

(1)

where (x, y) are the coordinates of the vehicle rear axle midpoint, φ is the robot orientation with the vertical, v is the speed, and γ is the vehicle curvature.

Once known its current configuration (x, y, φ, v), the robot has to control the values of its new speed (magnitude and driving direction) and its new curvature (v, γ) to achieve a good parking maneuver. The kinematic constraints of the robot impose that changes in the curvature can not be done abruptly if the speed is not zero. The dynamic constraints also call for soft changes in the speed, especially when the driving direction is switched between backward and forward.

The goal when driving forward is to lead the robot towards a configuration with x = 0 and φ = 0 (the vertical through the center of the parking place), so as to finish the parking maneuver by driving backward with an almost zero curvature. The approaching to the vertical is wanted to be done by approximating a short trajectory made up of arcs of circles of minimum turning radius and straight lines parallel to the line of cars (to avoid collisions and reduce the y distance traveled). These trajectories are shown in Fig. 4a.

The goal when driving backward is that the robot reaches the parking place with the target final configuration. Similarly to the forward maneuvers, the desired trajectories are made up of arcs of circles of minimum radius and straight line segments parallel to the line of cars, as shown in Fig. 4b.

IV. FUZZY CONTROLLER DESIGN The approximation we have taken to design this

controller is to directly emulate what we would do as drivers. In this sense, our first control action is to decide the direction of driving (the sign of the speed): backward or forward, and the magnitude of the speed. This decision is dynamic because it takes into account not only the current position and orientation of the vehicle but also its previous speed. This knowledge is included into a rule base that we call “direction”.

In addition, the constraints imposed by ROMEO 4R have to be considered when deciding the new speed. For example, the change of driving direction has to be soft since ROMEO has not an electronically controlled brake, currently. This means that the controller should never decide to go forward at a rather high speed if previously, the vehicle was driving backward at a rather high speed. This kind of constraints is considered by a rule base that we call “brake”. The input variables of this rule base are the speed decided by the rule base “direction” and the previous speed. Its output is the new speed that will be adopted by ROMEO.

The second decision is to select the proper angle of the wheels once we have decided to drive backward or forward. The speed selected by the rule base “brake” together with the x position and the orientation of the vehicle are the input variables of another rule base that we call “wheel”.

The resulting fuzzy controller structure is hierarchical, as shown in Fig. 5.

The rules of the modules “direction” and “brake” are easily defined from our heuristic knowledge. For example, two rules of the module “direction” are the following: 1.- “If the y robot coordinate is near the cars of the parking place and the robot orientation φ is greater than approximately –90º and smaller than approximately 90º and the x coordinate is not approximately zero or the orientation is not approximately zero, the driving direction should be forward to avoid collision with the parked cars”. 2.- “If the y robot coordinate is far from the cars of the parking place, the driving direction should be backward since there is no risk of collision”. Examples of rules of the module “brake” are the following: 1.- “If the speed decided by the module direction is forward and the current robot speed v is negative big, the robot should be stopped to not change abruptly its driving direction”.

Fig. 3. The parking problem addressed in this paper.

φ

y

x

Fig. 3. The parking problem addressed in this paper.

φ

y

x

Fig. 4. Example of ideal trajectories to be performed by the robot when driving (a) forward and (b) backward.

x

y

x

y

(a) (b)

Direction

xφ

y

vBrake

Wheel

v

γ

Fig. 5. Structure of the fuzzy controller.

Direction

xφ

y

vBrake

Wheel

v

γ

Fig. 5. Structure of the fuzzy controller.

2.- “If the speed decided by the module direction is forward and the current robot speed v is greater than negative small, the new speed of the robot should be forward since there is no risk of abrupt change in the driving direction”.

The above mentioned rules are fuzzy because they include fuzzy concepts like near, far, approximately zero, negative big, or negative small, which are represented by fuzzy sets. As a matter of fact, the universes of discourse of the input variables x, φ, y, and v are covered by membership functions, while the output variable v can take three singleton or discrete values: stop (0 m/s), forward (1 m/s) or backward (-1 m/s). The output of the rule bases “direction” and “brake” takes one of these discrete values by applying a maximum-type defuzzification process, that is, the output value is the consequent value of the most active rule. Hence, the description of the rule bases is done in a fuzzy way because it is much simpler (it is reduced to translating heuristic knowledge), but the output of applying these rule bases to a given premise is not a fuzzy but a discrete value. For example, Fig. 6 represents the driving direction provided by the module “direction” versus x and y when φ is 0 and v is 0.

Implementation of these rule bases into the DSP could be done by implementing directly the stages of the inference process: fuzzification (calculation of the membership degrees of each input variable to each fuzzy set in the rule antecedents), connection of the antecedents (for instance with the connective “and”) to compute the activation degree of each rule, determining the rule with the maximum activation degree and giving its consequent value as output of the rule base [7]. However, we have followed another implementation approach which is simpler: instead of implementing the stages of the fuzzy inference process to obtain a non fuzzy output, we firstly translate the fuzzy rule base into a non fuzzy one and implement the latter. The non fuzzy rule base does not need special operations (like fuzzification or defuzzification) but standard “if-then” conditional statements and standard relational and logical operators. For example, the fuzzy rule base “direction” is translated into the following non fuzzy rule base (expressed in C code), which is easily compiled into the DSP:

if(y<0.0) way=0; else if((y<=4.5) && (phi<90.0) && (phi>-90.0)) way=1;

else if((y<=10.0) && (v>0))way=1; else way=-1; if((y>0.0) && (x<1.25) && (x>-1.25) && (phi<12 && (phi>-12)) way=-1;

While the outputs of the rule bases “direction” and “brake” take discrete values (forward, stop, and backward), the rule base “wheel” provides a value for the curvature which can range from its minimum to its maximum.

Designing the rule base “wheel” to provide the short trajectories depicted in Fig. 4 is a difficult task by applying heuristic knowledge only. It is better to apply heuristics after a geometric analysis of the problem. In this way, the geometric analysis of the forward trajectories shown in Fig. 4a leads to the following mathematical expression for its curvature, γ:

⎪⎩

⎪⎨

⎧

<=>

=αφαφαφ

γifmfifmfifnmf

040

04 (2)

where the angle α associated with the switching in the curvature sign can be calculated as follows:

( )⎪⎩

⎪⎨⎧

≥⋅−<−⋅−

=RxifxsignRxifRxarxsign

2)(1cos)(

πα (3)

R being the minimum turning radius corresponding to the maximum curvature (mf04 = 1/R, mf04n = -1/R).

The symmetry of the problem makes the above expressions be also valid for the backward trajectories except for changing the sign of the variable φ.

Equations (2) and (3) are associated with an on-off control because the γ value presents abrupt changes, and would require stopping the robot to perform this hard switching.

One advantage of using a fuzzy rule base is that the transitions in the γ value can be smoothed so that the robot can follow approximately the desired trajectories without stopping and, hence, reducing the power consumption. Therefore, instead of the sharp decisions represented by equation (2), fuzzy rules have been employed in a module named “smoothing” as the following:

1.- IF (φ-α) is negativebig THEN γ is rightbig; 2.- IF (φ-α) is negativesmall THEN γ is rightsmall; 3.- IF (φ-α) is positivesmall THEN γ is leftsmall; 4.- IF (φ-α) is positivebig THEN γ is leftbig;

where negativebig, negativesmall, positivesmall, and positive-big are fuzzy concepts which have been represented by the normalized triangular membership functions shown in Fig. 7, while rightbig, rightsmall, leftsmall, and leftbig are represented by singleton values (numeric values).

Given particular angles φ and α, the value of γ provided by this rule base “smoothing” is obtained as a weighted average of the active rules (by applying a zero-order Takagi-Sugeno inference method) [8]. The use of

forward

backward

(m) (m)

Fig. 6. Control surface associated with the module “direction”.

normalized triangular membership functions in the antecedents and a zero-order Takagi-Sugeno inference method makes this fuzzy rule base provide γ as a piecewise linear function of (φ-α), and, hence, it can be translated into a non fuzzy rule base. In our case, considering that sfw = (α-φ), and fw = γ, this non fuzzy rule base is as follows (in C code): if(sfw>=0.0) sfwuns = sfw; else sfwuns = -sfw; /*to exploit symmetry*/ if(sfwuns < 4.0) fw = -0.039*sfwuns/4.0; if((sfwuns >= 4.0) && (sfwuns < 30.0))fw = -0.039-0.361*(sfwuns-4.0)/26.0;

if(sfwuns >= 30.0) fw = -0.4; This rule base can be implemented easily in the DSP

since it uses relational and logical operators, standard if-then conditional statements, and addition and multiplication operators available at the DSP.

In the other side, computing the angle α with equation (3) is not efficient for the DSP since the function ar cos() is not available. Fuzzy logic has been also exploited at this step by using another fuzzy rule base, named as “interpolation”, to provide a fuzzy approximation of this angle. Their rules are as follows:

1.- IF x is leftbig THEN alpha is bigclockwise; 2.- IF x is leftsmall THEN alpha is smallclockwise; 3.- IF x is rightsmall THEN alpha is smallcounterclock-

wise; 4.- IF x is rightbig THEN alpha is bigcounterlclockwise;

where the fuzzy concepts leftbig, lefsmall, rightsmall, and rightbig are represented again by normalized triangular membership functions, while bigclockwise, smallclockwise, smallcounterclockwise, and bigcounterlclockwise are represented by non fuzzy numeric values.

Again using a zero-order Takagi-Sugeno inference method makes this rule base provide a value of alpha as a piecewise linear function of x and, hence, it can be translated into a non fuzzy rule base as in the module “smoothing”.

As a result, the structure of the module “wheel” of the fuzzy controller is shown in Fig. 8. Fig. 9 shows the control surface provided by this module when the driving direction is forward.

V. EXPERIMENTAL RESULTS As commented in the previous section, the rule bases

“direction”, “brake”, and “wheel” of the controller have been described firstly in a fuzzy way to translate our heuristic knowledge easily, and secondly translated to non fuzzy rule bases to adapt them to the DSP resources. The non fuzzy rule bases have been expressed in C code (as commented above). Since the embedded platform employed is based on a low-cost fixed-point DSP, fixed-point data formats have been employed in the C code so as to maximize the accuracy (avoiding data conversions) and minimize the size and the execution time of the code (avoiding software emulation). Care has been taken to avoid numerical errors due to truncation, rounding, and overflow. The fixed-point code has been downloaded then to the DSP using Code Composer StudioTM development environment of Texas Instruments.

The memory size occupied by the fuzzy controller implementation is 851 words of 16 bits of Data/Program RAM. Once the robot configuration is available, the time spent by the DSP in implementing the fuzzy controller ranges from 19.3 to 21.4 µs (the total time spent in computing the robot configuration, implementing the fuzzy controller, and assigning the new values of speed and curvature ranges from 35.0 to 37.1 µs). It is interesting to notice that the direct implementation of a similar fuzzy controller (without following the approach described herein) in a 486 PC takes about 2 ms, that is, 2 order of magnitude slower.

Fig. 10 and 11a show examples of experimental trajectories followed by ROMEO 4R controlled by our

Fig. 9. Control surface of the module “wheel” when driving forward.

(m)(degrees)

x (m)phi (degrees)

Fig. 9. Control surface of the module “wheel” when driving forward.

(m)(degrees)

x (m)phi (degrees)

(m)(degrees)

x (m)phi (degrees)

Fig. 7. Membership functions in the module “wheel” .

α−φ

neg. big

neg. small

pos. small

pos. big

Fig. 8. Hierarchical structure of the module “wheel”.

Interpolation x

φ Σ

alpha

+- Smoothing

γ

v

MUX

embedded DSP-based fuzzy controller. Simulation results obtained with the original fuzzy controller (prior to any translation) are very similar to experimental results with the embedded controller, as illustrated in Fig. 11.

VI. CONCLUSIONS The control problem of parking a car-like robot has been

employed to illustrate how to implement efficiently a fuzzy controller into a low-cost DSP-based embedded platform. The use of hierarchical structures and the choice of membership functions, connective operators, and inference methods suited to the DSP central processing unit make it possible to implement fuzzy controllers into standard DSPs to achieve real-time embedded control applications. Since the memory resources and the processing time required by the fuzzy controller are low, the DSP can be used not only to implement low-level control tasks, as usual, but also high-level ones.

REFERENCES [1] D. Driankov, A. Saffiotti, eds., Fuzzy logic techniques for

autonomous vehicle navigation, Springer-Physica Verlag, DE, 2001. [2] M. Sugeno, M. Nishida, “Fuzzy control of a model car”, Fuzzy Sets

and Systems, vol. 16, pp. 103-113, 1985. [3] S.-G. Kong, B. Kosko, “Comparison of Fuzzy and Neural Truck

Backer-Upper Control Systems”, Chapter 9 in Neural Networks and Fuzzy Systems, B. Kosko, Prentice Hall, 1992.

[4] A. Ollero, B. C. Arrue, J. Ferruz, G. Heredia, F. Cuesta, F. López-Pichaco, C. Nogales. “Control and perception components for autonomous vehicles guidance. Application to the Romeo Vehicles", Control Engineering Practice, vol. 7, pp 1291-1299, October 1999.

[5] TMS320LF2407 Evaluation Module. Technical Reference, Spectrum Digital, Inc., 2000.

[6] TMS320LF2407 Reference Guides, Texas Instruments, Inc. [7] I. Kalaykov, B. Iliev, R. Tervo, “ DSP-based fast fuzzy logic

controllers”, in Proc. European DSP Education & Research Conference, EDERC 2001.

[8] T. Takagi, M. Sugeno, “ Derivation of fuzzy control rules for human operator’s control actions”, in Proc. IFAC Symposium on Fuzzy Information, Knowledge Representation and Decision Analysis, pp. 55-60, Marseille, 1983.

Fig. 10. Experimental results.

(a)

(b)

x (m)

y (m)

x (m)

y (m) initial configuration: x= 8.0 m y= 10.0 m φ= 0º

initial configuration: x= -2.5 m y= 3.0 m φ= -117º

Fig. 11. (a) Experimental results. (b) Corresponding simulated result

(a)

(b)

x (m)

y (m)

x (m)

y (m) initial configuration:x= 1.8 my= 1.5 mφ= 81º

Fig. 11. (a) Experimental results. (b) Corresponding simulated result

(a)

(b)

x (m)

y (m)

x (m)

y (m) initial configuration:x= 1.8 my= 1.5 mφ= 81º