Hi Wang

Try the following

Fuzzy Logic: Implementation and Applications

https://books.google.com.eg/books?id=0IQECAAAQBAJ&pg=PA126&lpg=PA126&dq=How+to+speed+up+the+response+of+the+fuzzy+logic+controller&source=bl&ots=rtXakkjWbd&sig=J5TjG_Ik1q_-I7rEY7S9i6XEhkM&hl=en&sa=X&ved=0ahUKEwjP1YW3sLHOAhXDyRQKHY23DOkQ6AEIQDAH#v=onepage&q=How%20to%20speed%20up%20the%20response%20of%20the%20fuzzy%20logic%20controller&f=false

Comparative Speed Control Study Using PID

and fuzzy Logic Controller

https://www.google.com.eg/url?sa=t&rct=j&q=&esrc=s&source=web&cd=7&cad=rja&uact=8&ved=0ahUKEwjP1YW3sLHOAhXDyRQKHY23DOkQFgg6MAY&url=http%3A%2F%2Fwww.isaet.org%2Fimages%2Fextraimages%2FB414001.pdf&usg=AFQjCNH-Fh_-j5PWAkVGBJKy3QWQMqIINg&sig2=SujnZS6owkJ_bFpp0CPYTg

Design and development of fuzzy logic controller to

control the speed of permanent magnet synchronous

motor

http://www.academicjournals.org/article/article1379941443_Mathew%20and%20Pandey.pdf

Good luck

Maki Habib

Dear Wang,

In order to speeding up of fuzzy logic controller you can use concept of an Analytic fuzzy control (an approach without classical rule base). See my researchgate Branko Novakovic and related articles in it).

Best regards,

Branko 

Dear Branko,

Can I implement the analytic fuzzy controller in Matlab simulink?

Regards

Vincent Ma

Dear Wang,

I did not implement the analytic fuzzy controller in Matlab simulink, but you can try it.

Regards,

Branko

Hi  Ravindra,

If the response speed problem is due to processing speed of each block and machine’s speed. Why the PID controller on the MATLAB platform don't have this problem?

Vincent

Dear Wang,

It is because PID controller has a simple structure and needs a small time for processing.

Branko

If I change the output range from [-6 6] to [-150 150] the settling time is much shorter but I have no idea why.....

Hey,

Just a few observations:

1. Whatever your controller is, what it ultimately does is provide an input to the plant (the system being controlled). Your controller was simply not providing a large enough output for the behaviour you wanted. When you increased the output range, your output values got scaled to the new range, thus your controller outputted much higher (150x) values. You can check this in the fuzzy logic designer in Matlab.

As a matter of general controller design, it's much easier to:

- design everything in [-1,1] and then use scaling gains on the inputs and outputs;

- always check the controller output (or the plant input, after scaling) to see what the controller is actually providing. 

The PID does this as well. You haven't mentioned your gains for the PID, but I'm guessing the P is a decently large value. Check the PID's output and compare it to the FLC's output to see where you might improve behaviour.

2. I don't think this has anything to do with processing speed. Your results are shown in simulation time, not in real time. It might take Matlab for example 1 minute to process 10 seconds of a particularly complex simulation (although a 3rd order system + FLC hardly qualifies as such), but in the end you get the results for 10s time. It's true that for very complex simulations there will be some calculation errors, but I don't think this is the case here. This would only ever (maybe) be a problem if you tried to run the controller on actual hardware.

If it bothers you that the simulation is lagging (in real time), just use an 'FLC' block without the RuleViewer. It will process the entire 20s simulation in about 2s.

3. There is no generally accepted hard rule to tune an FLC. That is, in a way, the entire point of the FLC: it models the experience / expertise one would have with the system being controlled (for example, you just learned that your system requires an input in the [-150,150] range :P). Without knowing the system's behaviour, there are still a few things you can do:

- use an optimisation algorithm (PSO, GA, etc.) to find the best values for input/output scales, membership function values and so on. This requires quite a bit of effort though, and it might be more than you're willing to put in at this stage.

ftp://ftp.ucauca.edu.co/Facultades/.FIET_serepiteencuentasyocupaespacio/DEIC.back/docs/Materias/Control%20Inteligente/proyectos/GAs/brutonj/JByrne_Meng_03.pdf

- start from an overall linear rule base (which you've already done) and amend it to your particular system. Run the simulation and see what you would like to improve, then adjust the rules and/or fuzzy sets to make it happen.

http://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118506227.html

- start from a controller that you know works well (your PID, in this case), see its output and try to model your FLC after that. Then do the same as above with adjustments.

For the system and .fis you've provided, 150 seems to be a good output scaling factor. So, to further improve the results, you'll probably have to modify the rule base/ rule weights / fuzzy sets in the FLC. I've included a modified version of the .slx and .fis to show what I mean by scaling (it gives the same results as your previous version).

Let us know how it turns out.

Regards,

Victor

 Hi Victor,

Thanks for your detail explanations. For the PID controller, the optimum response I can get was 3.27s settling time and 2.01s rising time (without overshoot) . The kp, ki and kd are 27.11, 0.88 and 86.26 respectively.

It is not difficult to tune the PID controller in Matlab using response optimization function but for fuzzy controller it took me a lots of time to "guess" (by trial and error) the optimum input and output range. Is there any function in Matlab I can use in order to "tune" the gain for the fuzzy controller?

Your controller was simply not providing a large enough output for the behavior you wanted.

I have one more question about the fuzzy controller. As there are only two inputs for the fuzzy controller (proportional and derivative inputs). I wonder how to reduce the steady state error without the integration input?

Hey,

For the PID controller, the optimum response I can get was 3.27s settling time and 2.01s rising time (without overshoot).

Ok, so we know the FLC is under performing. I would again suggest that you compare the output of the two controllers. What is the PID doing that the FLC isn't, and why? This should give you some idea of how to change the rule base to your liking. Btw, I can't replicate your results with the PID, and Ki=86.26 seems very strange. Could you post your PID too?

It is not difficult to tune the PID controller in Matlab using response optimization function.

I'm not familiar with the response optimisation tool, but Matlab has quite a few options for classical controller tuning (see also 'pidTuner'). I guess they concentrate on these because PIDs are everywhere and they're much easier to optimise, since they're basically deterministic transfer functions. 

but for fuzzy controller it took me a lots of time to "guess" (by trial and error) the optimum input and output range. 

Precisely why I would suggest you design everything in a [-1,1] range and scale the inputs and outputs through trial and error. That doesn't mean you need to guess blindly. For example, you already knew that you can get decent behaviour with your PID (27.11,0.88, 86.26) - I'm assuming parallel PID here, but the point stands for any PID structure. That means the error (which is usually between -1 and 1 for a basic step response, unless something goes very wrong) is multiplied by 27.11, its derivative multiplied by 0.88, etc. and all of these are added up (this is what a PID does). Obviously the output range isn't going to be [-1,1] or [-6,6], as you initially tried it, it's going to be in the double or triple digits.

Why for the PID controller I don't need to consider the output gain??

Well, in the case of a PID, you can get a good guess of what the output range is just by looking at its gains. Also, in your case, you used a Matlab tool to optimise the PID gains, so you already knew "analytically" that you were getting a good controller. However, it's always a good idea to consider the output when you're designing a controller. 

I have one more question about the fuzzy controller. As there are only two inputs for the fuzzy controller (proportional and derivative inputs). I wonder how to reduce the steady state error without the integration input?

Just because you can trace the overall controller action to a particular component in the case of a PID, doesn't mean you can or need to do it with every controller. There are many other types of controllers out there. If you were designing and RST or a Lead/Lag, you wouldn't be worried about integral action either. In any case, the FLC doesn't work that way. The de/dt input, for example, is just extra information that you feed into your logic. It doesn't do the same basic thing as it does in a PID.

Is there any function in Matlab I can use in order to "tune" the gain for the fuzzy controller? How can I use optimization algorithm (PSO, GA, etc.) to find the best values for input/output scales?

As far as I know, there is no direct option (function, tool, etc.) in Matlab to tune an FLC. To use an optimisation algorithm, you need to code the objective function and run the simulation inside the algorithm to get results at each step. Fair warning though, this is usually an application onto itself. See my answer on this question:

https://www.researchgate.net/post/How_to_update_Rule_base_scaling_factors_and_membership_functions_of_a_fis_file_in_Simulink

and especially the link I provided in the previous response:

ftp://ftp.ucauca.edu.co/Facultades/.FIET_serepiteencuentasyocupaespacio/DEIC.back/docs/Materias/Control%20Inteligente/proyectos/GAs/brutonj/JByrne_Meng_03.pdf

In reality  the transfer function (plant)  will change from patient to patient  but it is not possible to tune the controller for each patient..... That is the rationale why I replace my PID controller with fuzzy controller. 

As I understand it, the FLC should be more robust "out of the box" than just about any controller.  But you can't optimise for 'whatever happens'. As in any problem, something has got to be fixed. If your plant doesn't vary wildly, I would suggest you tune the FLC for your current model, then slightly vary the plant transfer function or introduce noise and disturbance into the model, to see whether the controller can handle it.

The problem with fuzzy controller is that most of the books or text only talk about how to set rule but not much cover about how to choose membership function and why a specific input and output range was chosen which is the core of fuzzy logic design. Before I try to design the fuzzy controller I think the most important thing is to set rules after that the controller would "take care" of the output....

I truly do sympathise with this. It's very frustrating to be told this should be a better controller, but still there's no exact guidelines to designing it, not even a generally accepted algorithm to follow. The consensus here seems to be that, when you don't know the plant, you start off from a linear rule base and modify it based on what you observe happening with the simulation. This is the book by J. Jantzen I was referencing earlier (first link in previous reply).

I do feel I should point out again though that this is part of the very nature of FLCs. There will be some trial and error when you are designing it that can't be avoided, since you don't know the system beforehand.

I would suggest the following:

- start from the simplest FLC that you have that actually works;

- run the simulation (with RuleViewer, scopes on inputs and outputs, so you can see what is going on) and see where it doesn't behave as it should. Maybe it decreases its output too early, or maybe it continues to give a large output when the system is close to settling, etc. 

- compare with the PID for ideas on where the FLC is not working well.

- use your knowledge of the system (how should the breast compression system work in real life) as extra inspiration for making changes.

- change the MFs and/or rule base to change the FLC's behaviour.

Victor

Hi dear Wang,

I think its a popular dellima in FLC realm.

I found some probable solutions for your problem, I wish they be helpful.

Well, first about your solver, I think using faster solvers like ode23tb (stiff\TR-BDF2) including a different Max step size can improve your controller speed. You can access these in configuration parameters.

On the other hand in signal poerties, Tab: logging and accessibility; By increasing Decimation to some integer  you can have a faster signal transfer and somehow a faster controller. It is upon your manipulation via limit data points and decimation.

Be aware that your input numbers in all above parts should justify the convergence of your controller time.

Finally, I in your shoes prefer other signal processings or controllers like: LabVIEW software or micro controllers for such immense logic controlling due to their high speeds.

May change defuzzification method.may be mom

Hey All,

Its Urgent,

Can anyone provide me C language code for fuzzy logic speed controller. I'm doing this Using ENERGIA interface.

I'm taking my inputs using a ultrasonic sensor and after fuzzy methods the outputs are taken by DC motors as their inputs and then after they are going to control the speed or the rotation speed of DC motor.

I'm thankful if anyone can provide the C language code for this.

Thank You

One option is to parrellelize some of its operations

You can also use Mex function in Matlab. They are faster