Victor logistics.

Hello. Does anyone know how the victors turn a servo pwm(1-2ms pulse) to a 0 - 100% pwm? Do they have their own “built-in” micro controllers? Is there a way to mimic this effect on a general microcontroller(arduino for instance?) with clever programming?

The main reason i’m asking is I might design my own speed controller for an off-season project and I’m hoping I could interface it with standard RC type receivers. Thanks:cool:

While I’m more mechanical then electrical/programming, I know that the servos are not plugged into victors, but into one of PWM ports on the R.C.
this is from rule R62

Servos must be directly connected to the PWM ports on the Robot Controller. They
must not be connected to speed controllers or relay modules.

Im not sure exactly how the RC deals with them except that they go to the PWM port.
I’m sure someone better versed in that area could help you.

Victors are also connected to the PWMs.

You have an input voltage that goes into a black box, is modified by a signal, and comes out the other side. That’s about all I know, except that FETs have something to do with it, and you need to keep the black box relatively cool.

I once found the spec for it, and built a signal generator using a couple of 555 Timers and a potentiometer. If you are really interested, I can try to find the specs again.

I had major control issues with it though, but I was only using 5% resistors.

Jacob

The victors do contain a microprocessor that measures the duration of the pulse, and sets the duty cycle and direction of its H-bridge. You don’t need to be very clever in the conversion: Take the width and map it onto your duty cycle. Here is some bad pseudo code to get you rolling.

if(width > positive_dead_band):
   direction = positive
   duty_cycle = ( width - positive_dead_band ) / scalar_constant

else if(width < negative_dead_band):
   direction = negative
   duty_cycle = ( negative_dead_band - width ) / scalar_constant

else:
   don't move

If you are attempting to connect a Victor to a hobby servo output, you may need to purchase one of IFI’s amplifiers. These simply beef up the drive strength of the signal.

As a point of anality, H-Bridges are controlled by DCM - Duty Cycle modulation, not PWM - Pulse Width Modulation. The two are electrically identical, but conceptually very different.

PWM is a serial communication protocol (albeit a weird one). In a PWM signal, I can adjust the dwell period between pulses without changing the meaning (to a point). Its “inputs” are pulse width and update rate.

In a DCM control, I can adjust the frequency without changing the output (to a point). Its update are percent high and frequency.

Yes, the distinction is completely anal. However, I believe it important so the students can better understand what an H-Bridge does.

Note that you can build your own 'Hobby PWM to duty-cycle" converter, using a servo amplifier like an NE544 (or a modern equivalent). Hobby or R/C PWM (the 1 to 2 mSec pulse signal) is converted to a variable duty cycle, which can then be used to control power MOSFETs or transistors to drive a motor or other load.

Don

Victors actually do two things to control their load.
Vary the duration of an output pulse and control the polarity
(For the purpose of simplicity I may omit actual values and substitute simpler forms.)

They evaluate the length of the input pulse. i.e. 1ms to 2ms is the range of duration, with a frequency of about 40 cycles per second. If 1.5ms is the middle value a duration greater than this will produce a short full voltage pulse at the output. Keeping the math simple: a 1.6ms pulse input produces a 12V pulse of 5ms duration 40 times a second. A 2.0ms pulse input produces a 12V pulse of 25ms duration 40 times a second. If you cheat and do the math I’d hear you say “hey wait a minute, for a 2ms pulse this thing always puts out 12V” and I’d agree.
Now for pulses less than 1.5ms the victor swithes the + and – polarity and adjusts the output pulse length in the same fashion.

The Transistors in the H bridge are switched on and off at a varying duty cycle which produces the variable power needed to adjust the motor speed.

In the following diagram the red trace is the pwm input, the blue trace is the pulsed output and the green trace is the output power averaged over the25ms period.





thanks 1680Bruce, but I understand how victors control a motor with varying pulses. I also understand that the control signal going into a victor is different than what comes out. What goes on in between these two signals is a mystery.

let’s say I used some general microcontroller. Pretend that the “servo-type” signal goes into this microcontroller. Now i’m guessing that this microcontroller needs to measure the time of the input pulse. The time of the input pulse could then be applied to some formula or something to transform it to “motor-type” control signal.
How would one go about measuring the length of the “servo-type” pulse?

No, as stated in my first post, I am attempting to design my own controller.

I am also looking to design a speed controller, and have thought for a while about this problem. The biggest issue is switching polarity based on the length of the pulse. I assume the Victor achieves this with a microcontroller, which also lets it have a deadband and the ability to be calibrated. If you don’t want to get into that, you can do the following much simpler design. I haven’t tried this, but plan to, and see no reason why it wouldn’t work.

Have the PWM signal control the speed, but not polarity, of the output. This just requires some big FETs. Have two separate digital outputs control the polarity via an H-bridge. More info can be found here: http://roko.ca/articles/hbridge.php?page=3

Note that you don’t need a microcontroller for this - a servo amp, a 555 circult, and other ways exist that are entirely in hardware.

But, let’s say you wanted to do it in a uC just for the learning experience.

First, you need a comparator to clean up the incoming PWM signal and slice it at a good decision level, say 2.5 volts (for a 5v PWM signal). Feed the output (TTL level) into an input pin on the uC. Set a timer to start when the pin changes state (low to high, for example) and read the timer when it changes state again. Store that value, it’ll translate to a value between 0.9 mS and 2.1 mS (or so).

Meanwhile, reset the timer and set it to trigger at the next pulse.

Then, using one of several methods (I suggest a look-up table), set the on-off ratio of an output pin to a value between maybe 0/5% and 95/100%. Pick a pulse rate between about 500 Hz and 4 kHz, but that can realistically be between 60 Hz and 20 kHz or more.

This output pulse controls an H-Bridge - homebrew with discrete FETs or bought as an H-Bridge module.

When the on-off ratio (duty cycle) is 50%, the motor won’t move, since forward voltage and reverse voltage cancel - the motor won’t move forward or backwards, the pulses are too short and evenly balanced. At 5% duty, it’ll move backwards, and at 95% it’ll move forwards.

If that’s not enough to get you started, write back.

Don

One of the larger problems would be to actually choose the right MOSFETs and drive them correctly. I did a bit of intensive reading and found two things

  1. high side mosfets (near to +ve) and low side mosfets (near to GND). A pair of high side and a pair of low side MOSFETs make up a HBridge.

  2. MOSFET drivers - faster u saturate the mosfet, lesser heat generated, lesser power losses

  3. proper timing to prevent “strikethroughs” where +ve is shorted to ground during switching.

  4. balancing resistors to provide proper distribution when running MOSFETs in parallel

  5. dropping in a hall effect sensor for current sensing is good too.

Being unfamiliar with discrete MOSFETs, I did run them off a TLE5205 (5A constant) Hbridge which takes TTL inputs. Next step would be to run some 5205s in parallel - or try discrete MOSFETs…

Unfortunately TLE5205s are rather hard to find in my area recently. Not sure for you guys.

Are you making this control in a pure hardware design via logic gates or in a software application running on a microprocessor?

In either case to convert from the lower signal level to the higher drive level would require a measurement of both input and desired output against a continuous and stable reference. In hardware and in software this would be derived from a clock oscillator like a 555 chip.

Signal conditioning and output sequencing are extra to the basic functioning of measuring against a reference so these would be dependant mostly on and specific to whatever components you choose for implementing your design.

No, as stated in my first post, I am attempting to design my own controller.

Are you using the Arduino? The uC on it should have a hardware based PWM generator suitable for driving H-Bridges… try reading the datasheet :slight_smile:

Do share with us what MOSFET you are trying out and how easy/hard it is to interface them. :smiley:

yes, as soon as I figure everything out/purchase parts I’ll make a project page.

Actually, H-Bridges can be made with all low side Metal Oxide Semiconductor FETs. This being that N channel fets can handle much more current than the high side fets.

Also, there are more than a few ways to make an H-Bridge work. The pair of low side and high side MOSFETS are just one of them, this being that only 1 signal comming in will only activate FETS that are diagonal to one another. Reffering to the classic H formation on an H Bridge. This method is easy to make, and prevents shoot thru…

Method 2 uses only N channel fets, but requires an inverted MOSFET driver to drive each Side, so driver 1 controls the upper left and lower left, while driver 2 controls upper right and lower right. This also prevents shoot thru of current.

Many more ways to make an H bridge.

Signals of 1 - 2ms enters on one end, with 1.5ms being neutral. The other end where the motor is connected to, has a duty cycle that varies. going from low frequencies such as 20hz to 40Khz. varies greatly, most applications, a frequency of 6khz is about just in the middle. I read that from somewhere, but can’t source it.

As for the polarity changes, you can make the microcontroller do that for you. Make an H bridge with a pair of MOSFET Drivers connected to the Gates on the mosfets. then have your digital output pull up or pull down the inputs on the MOSFET Drivers. The mosfet drivers are used because of the low gate resistance on the MOSFETs them selves. Having low resistance when a high current prescence at the channel makes the gate hard to open. So by using a driver, you can dump high currents at the gate at high frequencies to allow the channel to flow. If you need high duty cycles, you will have to load your routine in the user_routine_fast.c file. And go from there.

You can start experimenting with a bread board, and single mosfets first. after you know the fundementals, you can beef up and parallel your MOSFETS to handle currents as high as 80 amps steady loads or more.

As far as I know, the Victors use FETS that are about 65Amps on each MOSFET on a steady load, but be careful, because the power dissapation can be around 40 -80W each, and the pakage is only about a cm^2 area if you attach a heat sink.

Those victors use 12 fets, 3 per quadrant of the H bridge. So it would be able to handle high current loads for longer periods of time. They were able to make the duty cycle efficient enought that the fets dont requre added heat sinks.

International Rectifier makes MOSFETS with various pakage types, the ones used on the Victors are pakage: TO-220

Microchip.com makes the MOSFET drivers, other do too…Anyways, look for a pdf document on the website: “Mosfet Driver guide” or something along the line, it helps you select the right MOSFET drivers for the right type of MOSFETs…
GL with your experiments!

Well said! :slight_smile:

Any recommended mosfet & drivers?

If you want to build a motor driver and are going to use 12 volt or more then there are some single chip solutions that can offer more ability. The victor everybody is familiar with is an open loop design. It provides no feed back or protections. If you going to use a micro controller to command the H-bridge then with a little more work you can have Current feed back, thermal protection and over current protection. With current feed back and knowing the motors current function then you can have sensorless speed control with fair accuracy. For low current motors look at the Freescale MC33887. For more current ability the ST Micro Electronics VNH2SP30 chip offers many features.
Infineon also offers the BTS 7960 and BTS7930. These are half bridge chips.
Pololu.com offers the first 2 chips on carriers and would simplify working with them. They are surface mount and not for bread boarding. Robotpower.com offers the simple H with the BTS7960. The nice thing about the VNH2SP30 is that it only needs the fixed frequency - variable duty cycle PWM on 1 pin. The other chips need 2 PWM outputs from the microcontroler. The next step to this is to control the speed controller over a serial buss. Note that the Lego NXT offers I2c and RS485 for this purpose. May be First and IFI will add some intelligence to the next generation speed controllers.

VNH2SP30 - 30A, surface mount only
BTS7960B - 60A half bridge

Personally would prefer the BTS7960 as two of them make a full bridge and I can directly drive them using the 2-phase PWM output of the PIC or ATmel controller, and you can also add a heatsink to it. Now my only issue is having a bunch of them shipped to my location…

The chips referred use duty cycle pwm up to 20Khz as input, this would not work with the RC pwm used on the microcontroller… At least, I think thats right.

As for mosfet types:


The IRF3704Z is a pretty powerful fet. And Current output to power dissapation ratio is fairly good.

Go here if you want to pick your own mosfet specs.
https://ec.irf.com/v6/en/US/adirect/ir?cmd=eneNavigation&N=0+4294841672

You can read this guide for pairing up FETS with drivers. Provided by Microchip.com