Not sure how to go from PID error to PWM duty

Question

I am trying to learn the basics of PID. I have made a contraption to try to implement a PID controller.

I am not using carbon fiber, but rather a chopstick.

So I am controlling the speed of the propeller with a PWM signal through a mosfet from an STM32. I think 14Khz...Dont recall what frequency I set it to. My counter control register which controls my duty cycle can vary from 0 to 1000.

I am reading the pot value through the an ADC channel.

In my attempt to implement one control method at a time. P then I then D I never got past P because I dont know what to do with the value I get.

For example, Let say my chopstick is level (parallel to floor) at an ADC value of 2000. and I currently read 1200 then my error is 800. According to PID literature this gets multiplied by a gain. lets say the gain is .5 So now my P value is 400. But what do i Do with that? I cant set the PWM CCR to 400 that is too low a duty cycle and it will drop even more.

So that is my issue how do I translate the value to something useful.

All I am doing right now is that if my error is grater than zero then PWM = PWM - 1; and vice versa for error less than zero Obviously it works really slow because I am using the value of 1 but this is NOT proportional control. At least i dont think it is.

EDit: I think has to do with my issue. SO Like I said in the comments I can get it to work (sort of) so long as when i disturb it I dont make it go above a certain point, otherwise It will fly all the way vertical have a huge error and then drop have another huge error and just keep going and going. And god forbid I try to make a target point that is above 0 deg that stays put for a few seconds and then oscillates again. I just think the complexity of this system requires more then the simple PID tutorials you see everywhere involving speed control of a motor. I would follow the edx course on this but I dont understand the math and their notations. No real number examples or anything. I do not learn well just seeing bunch of variables and no real world examples.

Answer 1

You need to make a distinction between the signals, the angle of the chopstick (range -90 to +90 degrees, assuming down = 0 degrees), the duty cycle of the motor (range 0-100% for zero to max speed), and the numbers in your system that represent those signals.

Do your PID mathematics in the signal domain. It doesn't matter whether you have a 11 bit ADC reading 2000 when the pendulum is at 90 to the floor, or an 8 bit ADC reading 200, they both represent 90 to the floor.

The first thing to do therefore is to draw your block diagram, and express gains, signal ranges etc in sensible signal units. Then, the first thing you do when you read an angle, scale and offset it into a signal. The last thing you do when you have a PID controller output signal is to scale and offset it into a number that will control 0-100% duty cycle at your motor.

Answer 2

You have implemented an I controller with a very low gain.

You haven't told us what the PWM CCR value is set to in order to reach your initial state (ADC = 1200). But no matter - as you said in a comment, you can apply external influence and modify the ADC reading , and the controller should react to oppose that influence.

What you HAVE told us is,

my error is 800. According to PID literature this gets multiplied by a gain. lets say the gain is .5 So now my P value is 400. But what do i Do with that? I cant set the PWM CCR to 400 that is too low a duty cycle and it will drop even more.

That is a way of saying that your gain is too low.

Having created a controller, you have to tune it for best response - that is, whatever best meets your goals (which you haven't told us either). Stating those would be a good start. They might be:

• Keeping the arm horizontal with acceptably small error (5 degrees) and acceptable step response (fast settling with < 5 degree overshoot) or
• Keeping the arm to any specified setpoint (angle) from 0 to 180 within similar limits.

Now you can let the controller do all the work, or you can give it some help.

Letting it do all the work:

Your first ADC reading is 1200 giving an Error term E = 800. You haven't told us what PWM setting gave that reading but you imply it is over 400 because "that is too low a duty cycle". So set the gain (Kp) high enough that E * Kp > current CCR value. The CCR (PWM duty cycle) will increase, reducing the next error. It will settle out at some error inversely proportional to the gain.

To reduce the error further : increase the gain further. At some point the gain will be high enough that the controller overshoots, the position bounces, the system becomes unstable.

Giving it some help:
You can use a-priori knowledge as an initial "guess" at the correct PWM ratio, and use the P controller to correct that guess.
For example, as the horizontal position is 50% of the potentiometer range, you might use 50% = 500 as a very crude guess at the "set point" for the CCR. If that gives you ADC=1200, Error = 800, then add (Error * Kp) to the set point. Now Kp = 0.5 gives you 500+400 = 900 for a considerable increase in power. This allows the control loop to work with considerably lower gain (Kp) which may help loop stability. Indeed, Kp = 0.5 may be too high already.

In either scenario there will be some remaining error : that's where the I term comes in.

Answer 3

You are overcomplicating things. The short answer is that you take your error, you run it through a PID (or other controller), and you apply that to your CCR register.

You can decorate that with other things (as when you realize that your fan thrust is roughly proportional to the CCR value squared), but that's what you do.

For error \$e_k\$ and output \$u_k\$ at time \$k\$, \$u_k = k_p e_k + k_i \sum_{t=0}^k e_t + k_d (e_k - e_{k-1})\$, unless you need a bandlimited derivative term, which gets a bit more complicated.

Answer 4

I think I understand your problem Edwin. You want to translate the value from the PID controller to PWM. My advice is to experimentally determine a mathematical function that maps the process variable (propellor speed) to the controller output variable (PWM value): try different equidistant PWM values and note the speed of the propellor (in ADC value). Then plot a curve for this in say Excel.