simple RPM question

There is *no* standard duty cycle that will ensure the RPM that you want. If you've read any motor control text, you usually see PID algorithms referenced. I'm sure you can find a good book in the library, but the short form (VERY simple velocity control) is:

// Express rotation as counts, its easier // Assume a fixed interval for each sample 1/10 of a second // (This saves time calculations) // Deal with converting rotational counts vs RPM somewhere else.

int target_counts = 20; // Target count 1/10 of a second int read_counts = counter(); // Read counts // Calculate error int error = target_count - read_count; counter_clear(); // Clear counter for next read

// Calculate power pwm_output = pwm_output + (error * GAIN);

Thank you for your reply, i was writing some PID code myself for my control system. I do have one last question. According to your code, the unit of "error" is counts. And i guess the unit of "pwm_output" is the duty cycle. "GAIN" is for the P_gain. But how can you add a duty cycle to counts? (pwm_output = pwm_output + (error * GAIN)) is that how you do it? Other question, since the PID control is a continous process, an interupt will be needed. How often should the interupt occur?

You have to think of GAIN as a parameter that converts the error from a number of counts to a time representing the difference between the desired positive pulse width and the current positive pulse width. Keep in mind that you don't really know what the desired positive pulse width is (if you did this would be a trivial problem), but knowing the error as a unit of time suffices because you *do* know the current pulse width.

At the same time, however, GAIN also adjusts how strongly the system reacts to error.

The code you were given earlier assumes that samples are taken every

1/10 second. You can use whatever interval works best for your application, however.

Note that there's no requirement that an interrupt occur at all on the sampling side, provided you know how much time has elapsed since the last sample. You may then adjust the count based on the actual elapsed time. Provided you have a reasonable timer interrupt mechanism, however, you may find it easier just to use an interrupt.

Finally, be aware that the code given earlier is not actually PID -- it's merely 'P' (Proportional), and is often "good enough" for many applications. I'd recommend trying simple proportional control before adding integral and derivative components.

I think you took my code sample too litteral. Motors, encoders, and amplifiers vary so widely, there is no way you can speak in anything but generalities.

This line is key:

pwm_output = pwm_output + (error * GAIN);

The pwm_output is some arbitrary number that represents the duty cycle, how about if we write it this way:

pwm_output = pwm_outpt + count2pwm(error);

The point is that if the expected position is less than where it should be, you increase the duty cycle, if the expected position is more, then you reduce the duty cycle. The idea is that your system reaches equilibrium.

Now this is (obviously) not PID, it is a velocity control algorithm. PID is more geared towards velocity and position.