Driving motors, lights, etc. from an Arduino output pin

Arduino output pins are generally rated at 20 mA continuous, with an absolute maximum rating of 40 mA. Therefore your circuit designs should not attempt to rely on driving a device needing more than 20 mA. Also, there is a limit to the total amount that can be driven at once. For example, if you are driving 20 output pins you cannot drive 20 x 20 mA (400 mA) because (depending on the exact chip) you may be limited to a total of 200 mA, and groups of pins are limited to 100 mA for the group.



A commonly-used technique is to use a MOSFET to drive loads, and in particular an N-channel MOSFET. An N-channel MOSFET is used as a "low side" driver, that is, it is designed to "sink" current.





The advantage of a low-side driver is that you can control more than the 5V on the Arduino output pin, without extra components. If you want to switch "high side" (that is, to source current) then an extra transistor is required, as described below.



A MOSFET is quite efficient, when turned fully on or fully off. When fully off, it presents a very high resistance between drain and source. When fully on, it presents a very low resistance (R_DSOn).

Because of the low resistance when turned on, there is only a small voltage drop between drain and source, and thus only a low amount of power is consumed in the transistor (and thus turned into heat).

For use with 5V circuits you need a so-called logic-level MOSFET which lets it be turned on largely or fully by 5V between Gate and Source (this is called V_GS on the datasheet).



A resistor between the output pin and the MOSFET gate limits the surge of current into the gate when the MOSFET is turned on by program logic. There is a very lengthy discussion about this on the Arduino forum: Myth: "You must have a gate resistor".

In the example given in the schematic, the 150 ohm resistor (R1) would limit current to 33 mA, even when presented with a short-circuit:



Too large a resistor, however, would slow down the turning on or off the MOSFET, and thus it would be operating in the non-saturated region for longer, which increases the R_DS value, causing the MOSFET to get hotter.

According to my calculations the turn-on time would be 2.2RC and thus using an example of 1350 pF input capacitance, and 150 ohm gate resistor, it would take:



See Wikipedia - RC time constant

Thus it would turn on in 446 nS which is probably acceptable.



In the schematic above R2 (10k) keeps the Gate at zero volts if the Arduino pin is not configured for output, this keeps the MOSFET off if the processor is booting and has not yet set the pins correctly.



In the schematic above D1 is wired across the coil of the motor to prevent reverse EMF from damaging the MOSFET. For non-inductive loads (eg. LEDs) this diode would not be necessary. A fast switching diode (eg. 1N4001) or Schottky diode would be appropriate here.

Possible alternatives would be:

• Transient-voltage-suppression diode
• MOV (metal-oxide varistor)
• Avalanche diode
• Snubber diode
• Schottky diode

To work out if the MOSFET can handle the current you are planning to use (and whether or not to use a heat-sink) first you calculate the power used, based on R_DSOn for the V_GS voltage that you are planning to use.

For example, R_DSOn at V_GS = 5V, might be quoted as 0.035 ohms.

The formula for power is



So, let's say the motor draws 2 amps, it would be:



Now we need to look on the datasheet for the "Thermal Resistance Junction to Ambient" (R_ØJA). In my example (RFP30N06LE) it is given as 80 °C/W.

So we multiply that by the number of watts, like this:



If we assume ambient is 25 °C then that means the junction temperature will be:



This must be less than the maximum quoted junction temperature (TJ_max), which if not quoted we can assume to be around 150 °C.



We would also check that we are operating within quoted voltage ranges. For example, V_DS is the drain to source voltage. In the case of the RFP30N06LE that is 60V, so using it with a 12V supply is well within spec.

We would also check the continuous drain current (I_D). In this case the MOSFET is rated at 30A, and we are planning to use 2 amps, so this is OK as well.

The circuit above was for a low-side driver, one that would "sink" current. At times, though, we want to "source" current, which requires a high-side driver. This is easy enough if we only want to control 5V, in which case we can connect the MOSFET up like this:



Things are backwards however, as we are using a P-channel MOSFET. It is off when the Gate is the same voltage as the Source (V_GS = 0), which means that we have to output 5V (HIGH) from the Arduino to turn the MOSFET off. To turn it on we need -5V at the Gate (relative to the Source) so we need to output 0V (LOW) from the Arduino to turn the MOSFET on.

Once again there is a current-limiting resistor (R1) of 150 ohms, to limit the Arduino output pin current, and a pull-up resistor (R2) to make sure that the MOSFET is off if the Arduino pin is not configured as an output.

---

Things get more complicated if we need to source more than 5V, because to turn the MOSFET on we have to have a V_GS of -5V or more (the Gate needs to be -5 relative to the Source, which is the opposite compared to an N-channel MOSFET). To turn it off we need to be able to set V_GS to zero. So, for example, if we need to source 12V then to turn the MOSFET off we have to present 12V at the Gate. This can't be done with the Arduino output pin. To achieve this, we need a "helper" transistor, like this:



The transistor switches the 12V from our power supply on or off, based on the Arduino output pin. The 1k resistor (R1) limits the base current to the transistor.

There would be about a 0.95V drop over the base/emitter junction (V_BE(sat)), so the current through base (I_BE) would be:



The current flow of 4.05 mA is acceptable to both the Arduino output pin and the transistor. We will reckon on a gain of around 10 at saturation so that means it can sink 40.5 mA through R2.

In order for R2 to drop 12V the current through it must be:



We calculated above that the transistor can sink 40.5 mA so this is acceptable.

Next we need to calculate the power dissipated by the transistor which will be the sum of the base-emitter power and the collector-emitter power.



Once again we have a flyback diode to protect the MOSFET if it is driving an inductive load.

To turn the MOSFET on we output a HIGH signal from the Arduino, which means the transistor conducts, and sinks the Gate of the MOSFET to ground, effectively making it -12V compared to the Source.

To turn the MOSFET off, we output a LOW signal from the Arduino, thus Q1 does not conduct, and therefore the 1k resistor (R2) pulls the Gate to 12V. Now Gate and Source are at 12V so the MOSFET is off (V_GS = 0).

---

Things get more complicated again if we want to switch more than about 12 V, because we need to keep V_GS within the specified range of V_GS(max) for the MOSFET. Check the datasheet, but V_GS(max) may be in the order of ± 15 V, possibly ± 25 V.

To do this we need to clamp the V_GS voltage with a 10 V zener diode, shown below as D2:



We know that we will have around 4.3 V on the emitter of Q1 (5 V - 0.7 V drop from base to emitter) thus the current through the emitter must be:



If the main supply voltage is off, then that entire 14.2 mA will be provided by the Arduino output pin, which is within tolerance for it.

However if the main supply (shown above as 24 V) is on, then most of the current will flow from the collector. This is known as the "alpha" ratio, caculated as:



Since β will be about 100, then we have:



In that case the base current will be 142 µA and the collector current will be 14.06 mA.

That should be enough current to "activate" the zener diode, causing it to maintain a voltage drop of 10 V over V_GS.

The 1 k resistor (R2) is to pull the gate quickly back up to the supply voltage if the transistor is off.




It is important that the MOSFET be switched on and off quickly, as it has low power dissipation when fully off (ie. no current flowing) or fully on (when there is a low resistance between gate and drain). At other times the power dissipation will be higher, and the part may get hot.

This won't be an issue for low-switching speeds (eg. turning garden lights on and off, or a fish feeder) but becomes an issue when doing PWM (pulse-width modulation) where you may be switching on and off many times a second.

The analogWrite function on the Atmega328-based Arduinos runs by default at 490 Hz. Tests indicate that the circuit above will take about 1 µS to switch on and 8 µS to switch off (if using the high-side driver) and 1 µS to switch both on and off if using the low-side driver.

This is one of the reasons for choosing a reasonably low value for R2 in the high-side driver. We rely on R2 to pull the gate of the MOSFET high when the transistor is turned off, and we need that done as quickly as reasonably possible. We could potentially use a lower value resistor for R2 (eg. 470 ohms) to increase the switching speed, but then Q1 (the driver transistor) has to switch higher currents, and we need to watch that this transistor (Q1) does not get too hot.



Another point which can be initially confusing is expecting the Arduino board to provide enough power to run a motor, or lots of LEDs. It won't, basically. The power supply on the Arduino is rated with enough capacity to drive the chips on the board itself, with a little over for extra chips like clocks, SD cards, etc.

It is not intended to drive a 3 amp electric motor.

In this case you have a separate power supply (maybe a battery, maybe a plug-pack) which is the "+5V" or "+12V" on the circuits above.

However it is important to connect the grounds. That is, connect the ground wire from the battery or plug-pack to the ground wire on the Arduino. That way they have a common "reference voltage".

AddOhms' YouTube video about MOSFETs: MOSFETs and How to Use Them

Mike Cook's tutorial on power: Power & Heat

Wikipedia: MOSFET

Afrotechmods: Transistor / MOSFET tutorial and What is PWM? Pulse Width Modulation tutorial!

Also see the links above regarding flyback protection and snubber diodes.



Voltages, currents and resistances on datasheets are often given like this: V_GS

That means V (voltage) between G (gate) and S (source).

They may also have a condition attached, eg.

R_DS(on)

In that case this means R (resistance) between D (drain) and S (source) when the MOSFET is turned on. The datasheet may specify different values for different conditions, eg. R_DS(on) when V_GS = 5V. In other words, the resistance between Drain and Source when there is 5V between Gate and Source.

Moving on from MOSFETs, let's look at using BJTs (Bipolar Junction Transistors) as switches.

The advantages of BJTs are that they are small and cheap. The disadvantages are that they are current-driven rather than voltage-driven like MOSFETs, and in general are more suited to low-power applications, like driving a few LEDs, a small motor or a relay.



This circuit is similar to the "low side" MOSFET driver described above. The emitter of the transistor is connected to Ground, so it "sinks" current. The transistor is an NPN transistor. A similar and common part would be the BC546/547/548 transistors.

Two important calculations here are the two resistors. R_B - the Base resistor, and R_L - the Load resistor.

Some loads (like motors) will not need a load resistor as they will be naturally current limited (however they may require a fly-back diode as described above).



Let's assume that we want to drive the LED with 20 mA, and we establish that the LED has a forward voltage drop of 1.7V (from the datasheet, or by measurement).

We can see from the datasheet for our transistor that (in this case) that the Collector−Emitter Saturation Voltage V_CE(sat) is around 0.4V with a load of 15 mA.

Thus the voltage drop over the resistor will be:



And since we want 20 mA to flow we can use Ohm's Law to calculate R_L:



So we'll use a standard value of 150 ohms for R_L.

Power dissipated by this resistor will be I²R, which would be:



Thus a 1/8 watt resistor would be fine.



We want to fully "saturate" (turn on) the transistor, so a fairly substantial amount of current will be required. The datasheet quotes the "Collector−Emitter Saturation Voltage" as being one when I_C is 150 mA and I_B is 15 mA, thus we can deduce that (at those current levels) the transistor will only have a gain of 10 (that is, 150/15) when saturated, thus we would require a current of 2 mA to flow through the Base to the Emitter (that is, 20mA / 10).

The datasheet says that the Base−Emitter Saturation Voltage V_BE(sat) is around 1.3V with a load of 15 mA, thus the voltage drop over the resistor will be:



Since we want 2 mA to flow we can use Ohm's Law to calculate R_B:



Thus a 2k resistor should be satisfactory.

Power dissipated by this resistor will be I²R, which would be:



Thus a 1/8 watt resistor would be fine here too.



Next we need to calculate the power dissipated by the transistor which will be the sum of the base-emitter power and the collector-emitter power.









The net result here is that we are using 2 mA from the Arduino output pin to control a 20 mA LED. Now, an Arduino can directly drive 20 mA, however the workings above should let you calculate resistors for other loads.