I have problem with the PI or PID code.

hmmpic · Joined: 09 Mar 2010 Posts: 314 Location: Denmark

I have problem with the PI or PID code.

Facts:
250W DC engine controlled at the moment with a PWM controller without loop/feedback. Now I have installed an encoder. All is running without the loop! I can measure the RMP and control the engine with the PWM from 500-4500 RPM. So the hardware and software is prepared to the next step, the PI or PID code.

Problem:
Implement of the PI or PID code.
The RPM is from 500-4500. Let say the PWM steering value is between (int16 )200 to 475.
I have looked and read but can’t understand how to make the implementation?
There are a SetValue and a measured EncoderValue when they are equal all is nice.

Hints

newguy · Joined: 24 Jun 2004 Posts: 1909

I'd suggest you read "PID Without A PhD" by Tim Wescott: http://www.embedded.com/design/prototyping-and-development/4211211/PID-without-a-PhD.

hmmpic · Joined: 09 Mar 2010 Posts: 314 Location: Denmark

OK I think i solved my confusing, it was understanding of the scaling values for the PID so it return a matching value for my PWM output.

hmmpic · Joined: 09 Mar 2010 Posts: 314 Location: Denmark

NOPE, i cant find the logic in the scaling.

My return signal is measured from the encoder end it return about 6000us and 53000us for the engine. That will say, fast rpm short signal return. It was the most simple way just to read the signal return time...

My PWM accept a value from 1 (150 is the motor lowest running duty) to 475 (99% duty).

Now I have to scale it but I can't, I'm confused. I don't know the relationship between the Duty and the RPM on the engine. The engine is _not_ linear to the PWM....

Maybe it's me there confusing it because I miss something in my brain, or think too much in the wrong direction?

I need some help on this.

temtronic · Posted: Thu Dec 03, 2015 11:36 am

One way is to run the PWM from 150 to 475 in say increments of 5 and record what the RPM of the motor is. Be sure to run for 5 to 10 seconds at each PWM level to get a solid RPM reading.
From those readings (about 66 of them) you should be able to analyze the algorithm of PWM vs RPM. These days you can just dump them into eXcel or MATLAB and have that program 'reverse engineer' the algorithm.

Jay

hmmpic · Joined: 09 Mar 2010 Posts: 314 Location: Denmark

yes, but is it important on a PI (D) system? It is all these considerations and thoughts I have and therefore I stalled?

Mike Walne · Joined: 19 Feb 2004 Posts: 1785 Location: Boston Spa UK

OK. You've been given several pointers.

What tests have you actually performed on your real hardware?
What were the results of those tests?
Or are you spending all your time just thinking about it?

Mike

Ttelmah · Joined: 11 Mar 2010 Posts: 19552

You need also to understand the three parts of PID.

'P'. Proportional. Basically it sets the ratio between the requested 'output', and what is delivered to generate this. Getting this close to right helps reduce the need for the other terms. A simple 'trigger' controller on a drill or something, will only have a 'P' term. It'll slow down if loaded, but does mean that f you pull the trigger half way, the motor spins at close to half it's full speed rate.

'I'. Integral. This integrates _errors_ between what is requested, and what is actually being generated. If the motor runs slower than expected, it is this that applies the extra boost to bring the speed back. Allows the system to cope with extra power needed for extra load, and improves the ability to change speed as load changes, but at the risk that with sudden changes things can overshoot.

'D'. Differential (or derivative). This looks at the rates of change. If the output is _already moving in the requires direction_, this 'backs off' the adjustment being applied. It is this that tries to 'trap' the overshoot that sudden changes can produce. The faster the device is moving towards the desired target, the more this is applied.

Tuning a PID should be done in multiple stages. You generate a P term, by working out what rate is needed typically for the minimum load, for a given required power, and calculate the factor for this. Then you apply load, and generate an I term, that can apply the extra power needed to compensate for this. Then you try changing position quickly and see how much overshoot results, and calculate a D term for this. If the D is too high, everything will work well, but responses will be a little slow. Too small, and there will tend to be overshoot when the requested position is changed quickly. I term too small, and the motor will tend not to compensate as load increases. Too large, and it'll tend to 'hunt', overcorrecting each way.

hmmpic · Joined: 09 Mar 2010 Posts: 314 Location: Denmark

Thanks the help on this.

It is now running well, therefore I post my solution for other there maybe can use it, or this discussion on it.

The project is to implement a PID system on a DC motor. I use a “Hall sw” to detect the speed. It return 4 impulses/rpm. Not much but the system is running well. It is feed to ex_int_0. The measurement is done with a free running timer there are read in the interrupt on every L-H pulses.
The setpoint is made with a potentiometer connected to one AD converter and scaled for min/max pulses matching the return signal.
The control system use PWM in my case 16,7kzh with a duty cycle from >0 – 99.
In my main loop there are a time scheduler to control the read of the setpoint every 100ms, and check for stalling motor every 500ms.
The measurement task is called in the main loop, but is under control or in sync with the return impulses. On every new impulse it set a bit there mean, we have new samples and can now do the PID, and there after update the PWM. Updating of the PWM is done in sync with the already running PWN.
I post here some of the code for other. If my code or my logic is wrong, I hope someone will post correction.

Read feedback puls: