Are we still using only 256 unique PWM steps?

It seems like that limitation should be lifted when using the cRIO board, which appears to be a rebranded NI-9076 board running the Xilinx Spartan-6 LX45 FPGA, which looks like it is a 16-bit controller, and that seems to usually be the “bit chokepoint” when trying to generate a pwm signal…This isn’t a limitation by the victors or jags are they? I haven’t taken apart a Victor, but it looks like there are just a bunch of LM317s in there. It looks like there’s a large capacitor. Now if you just have an RC filter in there (which explains the large cap), there should be no problem accepting a higher resolution PWM signal. I haven’t tried this. Would that be possible to do? Sometimes 8-bits just isn’t enough.

There are many good explanations of the PWM communication protocol on the web and on these forums. I suggest starting there before moving forward.

There are several fundamental misunderstandings in this section.

The FPGA is not a 16 bit controller.

The big capacitor is to handle the large current spikes when the bridge is switched.

These PWM signals are not decoded by an RC filter.

8 real bits certainly is enough for FRC.

The “bit chokepoint” in PWM is fundamentally limited by the IO update rate and the combined accuracy of the oscillators in sender and receiver.

I’d disagree that 8 bits is enough, but at any rate, how are the PWM signals decoded?

Also, what bit controller is the LX45? Everything I’m seeing is saying it’s 16-bit.

It is. See the following FAQs on the IFI Technical Support Forum:

I believe there is additional resolution when using a Jaguar in CAN.

You can’t think of an FPGA like you would a microcontroller. While you can embed a microprocessor core inside an FPGA, that isn’t implemented in the FPGA. Instead, you can implement as large of a bus or register as you have available I/O and gates.

Note: The xilinx microblaze is a 32 bit processor.

I can’t imagine what you might be referring to. Can you post a link?

The devices you think are 317’s are in fact IRL3103 Power MOSFETs in the Victor. As Eric pointed out the large cap on both the Victor and the Jag are to smooth power supply. 317s can’t handle brake mode, make a minimum of 1.25 volts output when the control input is grounded, can’t control 40 amps each and require a large diode for reverse polarity protection.
As to the resolution, most teams don’t use the ~120 bits (accounting for the deadband and only one direction) as it is and most don’t even calibrate the controllers.

A few small points on the PWM signals.

The WPILib API uses a single float value ranging from -1 to 1. Under the hood, it maps this between the usable high and low int values based on the calibration info. This doesn’t attempt to linearize the response, but does remove the outer shoulders. Even when not calibrated, these values are given mfr specific settings which should lead to pretty good performance, especially for drive motors.

As noted, neither the 9076’s Freescale processor or the FPGA are 16 bit. The FPGA, as used, has no cores. It is highly reconfigurable, but for FIRST, thus far it acts as the high-horsepower I/O engine. It is capable of I/O rates up to 40MHz, but the I/O modules, especially those selected for use in the FIRST competition, take many cycles to reconfigure. The digital module being used is highly flexible with 32 channels, but with an access time of around 6.5microsecs. For discrete I/O on the robot, this is often the limiting factor – encoder rate, PLM generation resolution, digital triggers, etc. As shown at, the 9076 is not the limiting factor.

Greg McKaskle

8 bits is more than enough for FRC, especially considering the PWM signal is actually a 1 bit signal.

You can get more resolution than 8 bits if you modulate the PWM command properly. For example, if you want 9 bit resolution you can alternately add and subtract a half bit from every output. For example, let’s say you really want an output of 132.5. In that case, send 133 one sample and 132 the next sample (over and over again) and the electronics and mechanics of the system will act just as if you’re sending 132.5. Of course, this depends on the system “time constant” being much slower than the rate you are outputting PWM commands (which it usually is for an FRC robot). If you want more resolution than that, you can create a fancy algorithm with a counter and a threshold, which is how PWM is actually implemented in many cases.

When I teach my students, I stress the difference between Pulse Width Modulation and Duty Cycle Modulation. It is a bit pedantic, but I feel that it helps to clear things up.

There are four measurements that can describe the timing of a square wave, but you can use any two to fully define it: duty cycle, frequency, positive width, negative width. The choice of which two depends heavily on the application, and helps separate the relevant factors.

PWM is dimensioned by the positive width (value) and the frequency (symbol rate). As frequency changes, the positive width stays the same to send the same information.

DCM is dimensioned by the duty cycle (applied ‘voltage’) and the frequency (allowed ripple). As frequency changes, the duty cycle stays the same to send the same average ‘voltage’ to the motor.

The microcontroller in a victor or jaguar measure the pulse width of the PWM signal from the cRIO and calculate an appropriate duty cycle for the DCM signal they send to motor through their bridge.

In mechanical terms, you can dimension a drawing many ways and produce the same part, but you may choose to show and hide a particular set to better communicate intention.

To beat a dead horse, 256 levels of PWM control are plenty. One must consider the system to which the output of the controller is connected - DC motors don’t really have much of a reaction to voltages that differ by something on the order of 0.1 volt. Take that into the mechanism to which the motor is attached, and inertia will foil you every time.

Once you have reached overkill, more is not useful.

*Doing the math for grins, a 4 microsecond change in pulse width signal to the Victor corresponds to roughly 0.8% change in the duty cycle output which is approximately equivalent to a 0.1 volt change seen by the motor.

A 0.1 change in voltage to a CIM operating at 12 volts into a constant load at the max efficiency point on the curve results in about a 1% change in motor speed.

I wonder how stable and accurate the pulse width coming from the DSC is. Has anybody ever hooked it up to a logic analyzer?

Ah, that makes a lot more sense. I was wondering how they would get by the 1.25 reference voltage of a LM317. I guess they COULD use LT3080s to get around that, but like I mentioned before, I haven’t taken a Victor apart (mostly because they’re not mine, and our team doesn’t have the kind of resources to waste on me accidentally breaking a Victor).

The reason I mentioned that it would be nicer to have more resolution is well…put it this way. This year, the majority of teams (including 3138), had shooter wheels with a speed controller. If your max speed (that is full voltage to the motors/128 counts) is 4000 RPM, which is easily attainable, the finest you can change your motor speed by is ~30 RPM, which can be a heck of a difference. I’m sure there’s got to be a way to use it as an unsigned value (that is 0-12V rather than -12-12V) to get 256 counts of resolution, but that would still only give you a 15 RPM resolution. While many teams figured out it didn’t make a huge difference, it would be nice from a controls perspective to be able to control it down to a single RPM (which would be attainable with a 12-bit PWM signal)


a) your wheel has sufficient moment of inertia, and

b) you are reading the wheel speed sensor, computing your control algorithm, and outputting a new motor command fast enough,

… then you are not limited by the resolution of the motor command.

In fact, you can get very accurate and stable motor speed with only 1-bit resolution of the command (ie ON or OFF), as described here.

Even an LT3080 would go vapor phase / light on fire / explode if used for this. Simply put, linear regulators are not used to drive motors. You should look up “H-Bridge” for some good explanations of how motor controllers work.

I’m still not convinced that you would actually see any benefit from additional resolution. The issue is resolution vs accuracy. In your 30RPM vs 4000 RPM example you have less than 1% error from resolution, but the accuracy is going to be many times that error from sources. For example, a good battery’s rest voltage will vary several volts over the course of a match, and the actual voltage seen will swing wildly during normal transient loads. Open loop, any extra resolution in the bridge’s duty cycle will be worthless.

To compensate, wrap a PID loop around an encoder on the wheel. This will help with the accuracy error sources, and will eventually oscillate around a few values as it tries to dial in the speed. It will never be perfect, but it should be good enough.

You have the power to do this, with some custom software.

What you need is an output converter function (or sub-vi) that takes your desired 12-bit value and modulates the 8-bit PWM value. The modulation of the 8-bit PWM signal will increase your resolution. Here’s an example of how to do it (get 12 bits from an 8-bit PWM):

  1. Multiply the PWM output command (0.0 - 1.0 for your shooter motor that you should only command in one direction) by 127. You should end up with a PWM command with a whole part and a decimal part.

  2. Take the decimal part and multiply by 16 and round to the nearest whole number. Call this number FractionalDuty. (Why 16? Because 12 bits has 16 time more resolution than 8 bits.)

  3. Take the whole part of the number from step 1 and call it WholePWM.

  4. In your fast loop, implement the following code:

if (counter < FractionalDuty)
   PWMOut = WholePWM + 1;
   PWMOut = WholePWM;

if (counter >= 16)
   counter = 0;

Finally, convert back to 0.0 to 1.0 by dividing by 127.

What this does is it adds a one-count duty cycle on top of the PWM signal. It does it by increasing the 8-bit PWM by one count for a portion of every 16 timer loops. For example, if your FractionalDuty is 4, then it will increase the PWM output by one count for 4 out of the 16 loops. This averages your PWM output to be an additional 1/4 count. This will increase the resolution of your output, providing that your system time constant is much larger than the frequency of your added one-count duty cycle.

If you implement the above code in a 10 ms loop, you are modulating the PWM signal over a period of 160 ms. Most shooters this year spun up in about 2 seconds, giving them a time constant of about 500 ms. That makes the ratio of time constant to control cycle about 3/1, which isn’t great, but it’s not too bad. You might see your shooter speed oscillate by 5 RPM or so.

Note that the above code is to get the 12-bits that you want. If you go to 11-bits, you only need eight 10 ms loops to modulate your PWM. That gives your control cycle to time constant ratio of about 6:1, which is getting pretty good.

Disclaimer: I’m typing this while I’m being distracted by something, so my math might be off a bit.

What we had resorted to this year was to bump the speed on our flywheel-like shooter wheel to keep it in the range we needed for a specific shooting solution. The software people can discuss this in greater detail. When needed we added a little power to the wheel motors to keep it in the range. We used a simple encoder for wheel speed feedback. The first time I heard it running, I thought it was broken.

Chris tackled how to get in-between PWM values by playing with the output signal.

To go a step further, you are stuck thinking in purely electrical terms here. You need to start thinking about the system you are controlling mechanically, which is what ether was getting at by pointing out control with bang-bang. More specifically you need to think about the inertia of the system.

You can send minute increases and decreases to the motors powering the wheels MUCH faster than the intertia of the wheel system will allow it to react. That means through the use of PID, or Bang-Bang, you can achieve much better resolution that your electrical system analysis would suggest, because the intertia of your mechanical system serves to damp or average the response.

In conversations with other teams that I trust, I heard of some managing to control as tightly as +/- 5 RPM. Our final value was about +/-13 rpm by the time I got sick of playing with encoders and Jaguars and gave up.

Being able to control it to a ‘single’ rpm in the way that you suggest wouldn’t work very well. It would take a very long time for the inertia of the system to respond to a tiny increase in voltage so that you could actually get to that rpm.