Table of Contents
- Introduction
- Simplified Voltage Divider Model
- (Some) Factors Affecting Design
- Loading Effects
- Thermal Effects
- Derating
- Analysis
- Summary
Introduction
A voltage divider is a circuit that scales (“divides”) an input voltage. A voltage divider can be made of resistors, but can also be made from capacitors and inductors in AC circuits. Voltage dividers are lossy, passive circuits which cannot add gain to a circuit. This means that a voltage divider will never produce a voltage higher than its input. In this article the non-idealities of a voltage divider circuit are discussed along with the mathematical formulas to aid in calculations. Additionally, a python utility for ratio determination is shown to assist in expediting designs.
Mathematically speaking, that is:
\[\Large V_{in} \gt V_{out}\]Simplified Voltage Divider Model
The voltage divider calculation is relatively simple using ideal components and ignoring tolerances. It is simply the ratio of the resistors $R_1$ and $R_2$ multiplied by the input voltage to the divider $V_{in}$.
\[\Large V_{out} = V_{in} \cdot \frac{R_2}{R_1 + R_2}\]Spherical Cow in a Vacuum
This equation assumes ideal components. Component tolerances need to be considered when designing because they will cause a deviation from this ideal equation.
Divider Functional Intuition
It is helpful to gain an intuition about how voltage dividers function when their parameters are modified. First, the input voltage $V_{in}$ gets scaled down by the resistor ratio, but as either $R_1$ or $R_2$ changes the result may not be immediately obvious.
| Action | Increase | Decrease |
|---|---|---|
| As $R_1$ goes up for a steady $R_2$, $V_{out}$ will decrease. It acts inversely upon the voltage. An increase in resistance yields a decrease in output voltage, a decrease in resistance yields an increase in output voltage. | $\Large R_1 \uparrow V_{out} \downarrow$ | $\Large R_1 \downarrow V_{out} \uparrow$ |
| As $R_2$ goes up for a steady $R_1$, $V_{out}$ will increase. | $\Large R_2 \uparrow V_{out} \uparrow$ | $\Large R_2 \downarrow V_{out} \downarrow$ |
Laser Trimming
Some resistors are offered with laser trimming. That is, a laser tunes the resistance to a final value. Laser trimming is a one-way operation as the laser ablates the material. Therefore, if the system over-trims it can simply trim up the other resistor to compensate for the error.
(Some) Factors Affecting Design
When designing a voltage divider, one must consider the manufacturing tolerance, derating, power limitations, thermal effects, and aging. High precision applications may need additional factors to account for thermal gradients leading to thermoelectric voltages. Additionally, resistors can also introduce significant parasitic inductance, or capacitances as frequency increases. This is outside the scope of this design, however.
Note that when designing for instrumentation and measurement applications, it isn’t always the exact value that is important. Usually, it is more valuable to have stability rather than a precise value. The deviation can then be calibrated out of the system allowing it to compensate for the deviation so long as the system remains stable over time.
Tolerance Effects
Tolerance effects are when a resistor’s value deviate from the nominal value. Resistors in reality are never perfect, however in most applications they can be suitable enough to achieve the end result. When resistors are manufactured, they are binned into “standard value” groups. This grouping is typically referred to as the “E series of preferred numbers”. These values depend upon their tolerance grouping but are what are typically sold as the nominal value. For example, if you purchase a $100 \Omega$ $5\%$ resistor its actual measured value may be $95\Omega$ to $105\Omega$. This is why understanding tolerance is important, particularly for applications demanding precision.
The effects of tolerance can be applied using the following tolerance equations:
\[\Large R_{min} = R_{nom} \cdot (1-R_{\%tol})\] \[\Large R_{max} = R_{nom} \cdot (1 + R_{\%tol})\]In design equations the resistance value can be substituted with the minimum and the maximum values to get the resultant deviation in output due to the manufacturing tolerances to get the “worst case” outputs.
Note on Tolerance Specifications
Tolerances can be specified as double sided $\pm \Omega$, or single sided tolerances $+\Omega, -\Omega$. The above equations assume a double sided tolerance.
Loading Effects
Loading effects in a voltage divider manifest as a change in output voltage when a load is applied. Consider how the voltage divider will be used. Anything that is connected to the voltage divider will load the output causing a deviation in voltage. The output impedance of a voltage divider can be calculated using the superposition theorem which states that voltage sources are to be modelled as a short. If the voltage source has a short then two resistors in series appear to be in parallel with respect to the output.
Applying a resistive load to this circuit can also be modelled in the calculation as a resistor in parallel with R2.
\[\Large V_{out} = V_{in} \cdot \frac{(R_2 \parallel R_{load})}{R_1 + (R_2 \parallel R_{load})}\]Thermal Effects
Additionally, resistors change resistance with temperature. The temperature change could be caused by ambient conditions and local heat sources, or even self-heating effects. The change in resistance can be calculated by applying the known heat rise from both ambient as well as self-heating effects to the temperature coefficient formula.
Self-Heating
Self-heating occurs when power is dissipated in a resistor due to current passing through it. This effect can significantly change the temperature of a resistor. In datasheets for some resistors, but not all, there will be thermal resistances published which can be used to estimate the temperature rise for a given dissipated power. These are usually specified as thermal resistance, case to ambient, usually in units of $K/W$. That is for every watt of power dissipated the device will increase by x Kelvin. Note that the magnitude of change is the same between $K$ and $° C$. So $+1K$ represents $+1° C$.
The power dissipated in a resistor can be calculated using Ohms law as follows:
\[\Large P_{diss(W)} = I^2 R\]This power value would then be multiplied by the specified thermal resistance to get the increase in temperature for thermal calculations.
\[\Large P\cdot R_{th} = \Delta T\]The self-heating effects can be minimized by providing a good thermal connection to the pads or connections of the resistor. Chassis mount resistors depend not only on the mount contact but also dissipate some heat through the connected wire leads too, for example.
Temperature Coefficient
The figure of merit for changes in resistors for a resistor is the “temperature coefficient” (TCR). This is usually specified in parts per million or $ppm$. This is a measure of how much a resistor will deviate over the specified change in temperature. Usually this is $ppm / ° C$.
To calculate the deviation due to a change in temperature the following equation can be used where the nominal resistance is typically the orderable resistance value, not including the tolerance effects previously calculated multiplied by the temperature coefficient of resistance (TCR) divided by one million ($1e6$). The result is the change in resistance that is expected.
\[\Large \Delta R_{TCR(\Omega)} = \frac{R_{nom(\Omega)} \cdot ppm \cdot\Delta T}{1e6}\]Additionally, the TCR specified is not always the TCR received. A batch of resistors will also have deviations in temperature coefficients, that is TCR is not necessarily precisely controlled between a parts batch or between lots. Often these temperature coefficients are much less than what are specified. Manufacturers do not necessarily want to guarantee the values to a tighter margin; however, they may guarantee they are below a limit. On a datasheet this could be shown as “maximum” TCR, whereas “nominal” may suggest most resistors have a specific temperature coefficient but could be more. A small detail that could introduce problems in sensitive applications!
Specifications
Note that the datasheet should have the reference temperature stated. That is, the change in temperature is from the specified reference temperature. Sometimes this is $20° C$, others $25° C$ or more depending on the intended application.
The temperature coefficient is often the most critical parameter in measurement and instrumentation applications since this affects the system stability. In some applications the effects of temperature can be cancelled, or calibrated out, by the addition of a temperature sensor which is thermally coupled to the device.
Derating
In order to ensure that the design has a long lifetime it is important to consider derating components. That is, stay far away from thermal and voltage limits. Always consider how the voltages are applied and utilized within the system to quantify any pulsed loading. For example, square waves will have different derating factors than sine waves for example.
Component manufacturer usually have recommended derating charts in application notes and datasheets that vary based on the application and use. Resistors tend to age faster when subjected to high stresses that approach their maximum specified limits. Sometimes it may be advantageous to size up a resistor simply for increased long-term stability. Aging characteristics are material, and application dependent. Typically, these involve using the Arrhenius equation to provide some estimation of drift. See Vishay’s technical note - “Drift Calculation for Thin Film Resistors” for detailed calculation methods as an example.
Analysis
There are a number of ways to calculate suitability for a design. Simple methods may be “hand calculations” such as using an excel spreadsheet to obtain worst case values. The design could also be simulated using statistical method such as Monte Carlo. This simulation can even be done using free software such as LTSpice.
It is first important to understand the design requirements. Only then can you find the component parameters that are able to synthesize a suitable circuit. There may need to be multiple iterations involved, particularly when the margin of acceptability is low.
Sensitivity Analysis
The following equations analyze the change in output voltage with respect to each of the component values. The equivalent resistance can be substituted with the calculated tolerance and thermal effects to understand the system impact.
\[\Large v_o = v_i \cdot \frac{R_2}{R_1+R_2}\] \[\Large \frac{\partial v_o}{\partial v_i} = \frac{R_2}{R_1 + R_2}\] \[\Large \frac{\partial v_o}{\partial R_1} = -v_i \frac{R_2}{(R_1 + R_2)^2}\] \[\Large \frac{\partial v_o}{\partial R_2} = v_i (\frac{1}{R_1 + R_2} - \frac{R_2}{(R_1+R_2)^2})\]where:
- $v_o$ is output voltage.
- $v_i$ is the divider input voltage.
- $R_2$ is the bottom resistor in the divider.
- $R1$ is the top resistor in the divider.
Ratio Determination
Once an analysis has been completed the design needs to be realized. That is, components selected that meet or exceed the requirements, that can actually be purchased. You may be able to custom order specific resistance values but often comes with substantial costs and lead times attached. (e.g. Caddock and Vishay Metal Foil).
Other times “close” is “good enough”. For those situations. In an effort to avoid repetitive calculations I have developed a simple solver application that can be used to help find the optimal voltage divider resistance combinations.
Voltage Divider Python Application
#########################################
# Voltage divider ratio calculator
# Author: LambdaFox
# Date: 05 November 2023
# Website: https://lambdafox.com
#
# Revision Log:
# 1.0.0 - Initial Release
import itertools
def preferred_values(series):
"""
Generate a list of E series of preferred numbers using a look-up list.
This function takes in a string value of an E-series
(E3,E6,E12,E24,E48,E96,E192) then outputs a list of values to use.
:param series: string input for E-series. (E3,E6,E12,E24,E48,E96,E192)
:type series: str
:return: List of all E-series values for all decades for the series chosen.
:rtype: list
Example usage:
.. code-block:: python
>>> preferred_numbers = preferred_values('E24')
>>> print(preferred_numbers)
[1.0, 2.2, 4.7, 10.0, 22.0, 47.0, 100.0, 220.00000000000003,\
470.0, 1000.0, 2200.0, 4700.0, 10000.0, 22000.0, 47000.0,\
100000.0, 220000.00000000003, 470000.0, 1000000.0, 2200000.0,\
4700000.0]
"""
_series = { 'E3':{'tolerance':40,
'values':[1.0, 2.2, 4.7]},
'E6':{'tolerance':20,
'values':[1.0, 1.5, 2.2, 3.3, 4.7, 6.8]},
'E12':{'tolerance':10,
'values':[1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2]},
'E24':{'tolerance':5,
'values':[1.0, 1.1, 1.2, 1.3, 1.5, 1.6, 1.8, 2.0,
2.2, 2.4, 2.7, 3.0, 3.3, 3.6, 3.9, 4.3,
4.7, 5.1, 5.6, 6.2, 6.8, 7.5, 8.2, 9.1]},
'E48':{'tolerance':2,
'values':[1.00, 1.05, 1.10, 1.15, 1.21, 1.27, 1.33,
1.40, 1.47, 1.54, 1.62, 1.69, 1.78, 1.87,
1.96, 2.05, 2.15, 2.26, 2.37, 2.49, 2.61,
2.74, 2.87, 3.01, 3.16, 3.32, 3.48, 3.65,
3.83, 4.02, 4.22, 4.42, 4.64, 4.87, 5.11,
5.36, 5.62, 5.90, 6.19, 6.49, 6.81, 7.15,
7.50, 7.87, 8.25, 8.66, 9.09, 9.53]},
'E96':{'tolerance':1,
'values':[1.00, 1.02, 1.05, 1.07, 1.10, 1.13, 1.15,
1.18, 1.21, 1.24, 1.27, 1.30, 1.33, 1.37,
1.40, 1.43, 1.47, 1.50, 1.54, 1.58, 1.62,
1.65, 1.69, 1.74, 1.78, 1.82, 1.87, 1.91,
1.96, 2.00, 2.05, 2.10, 2.15, 2.21, 2.26,
2.32, 2.37, 2.43, 2.49, 2.55, 2.61, 2.67,
2.74, 2.80, 2.87, 2.94, 3.01, 3.09, 3.16,
3.24, 3.32, 3.40, 3.48, 3.57, 3.65, 3.74,
3.83, 3.92, 4.02, 4.12, 4.22, 4.32, 4.42,
4.53, 4.64, 4.75, 4.87, 4.99, 5.11, 5.23,
5.36, 5.49, 5.62, 5.76, 5.90, 6.04, 6.19,
6.34, 6.49, 6.65, 6.81, 6.98, 7.15, 7.32,
7.50, 7.68, 7.87, 8.06, 8.25, 8.45, 8.66,
8.87, 9.09, 9.31, 9.53, 9.76]},
'E192':{'tolerance':0.5,
'values':[1.00, 1.01, 1.02, 1.04, 1.05, 1.06, 1.07,
1.09, 1.10, 1.11, 1.13, 1.14, 1.15, 1.17,
1.18, 1.20, 1.21, 1.23, 1.24, 1.26, 1.27,
1.29, 1.30, 1.32, 1.33, 1.35, 1.37, 1.38,
1.40, 1.42, 1.43, 1.45, 1.47, 1.49, 1.50,
1.52, 1.54, 1.56, 1.58, 1.60, 1.62, 1.64,
1.65, 1.67, 1.69, 1.72, 1.74, 1.76, 1.78,
1.80, 1.82, 1.84, 1.87, 1.89, 1.91, 1.93,
1.96, 1.98, 2.00, 2.03, 2.05, 2.08, 2.10,
2.13, 2.15, 2.18, 2.21, 2.23, 2.26, 2.29,
2.32, 2.34, 2.37, 2.40, 2.43, 2.46, 2.49,
2.52, 2.55, 2.58, 2.61, 2.64, 2.67, 2.71,
2.74, 2.77, 2.80, 2.84, 2.87, 2.91, 2.94,
2.98, 3.01, 3.05, 3.09, 3.12, 3.16, 3.20,
3.24, 3.28, 3.32, 3.36, 3.40, 3.44, 3.48,
3.52, 3.57, 3.61, 3.65, 3.70, 3.74, 3.79,
3.83, 3.88, 3.92, 3.97, 4.02, 4.07, 4.12,
4.17, 4.22, 4.27, 4.32, 4.37, 4.42, 4.48,
4.53, 4.59, 4.64, 4.70, 4.75, 4.81, 4.87,
4.93, 4.99, 5.05, 5.11, 5.17, 5.23, 5.30,
5.36, 5.42, 5.49, 5.56, 5.62, 5.69, 5.76,
5.83, 5.90, 5.97, 6.04, 6.12, 6.19, 6.26,
6.34, 6.42, 6.49, 6.57, 6.65, 6.73, 6.81,
6.90, 6.98, 7.06, 7.15, 7.23, 7.32, 7.41,
7.50, 7.59, 7.68, 7.77, 7.87, 7.96, 8.06,
8.16, 8.25, 8.35, 8.45, 8.56, 8.66, 8.76,
8.87, 8.98, 9.09, 9.20, 9.31, 9.42, 9.53,
9.65, 9.76, 9.88]}
}
#Error handling
if series not in _series.keys():
raise ValueError('Series provided not found!')
resistors = []
for decade in [1, 10, 100, 1000, 10000, 100000, 1000000]:
for resistance in _series[series]['values']:
resistors.append(resistance * decade)
return resistors
class Solver():
"""
Iterative solver base-class for general usage as an optimization tool.
This class allows subclassing functionality to tailor the optimizer to
additional problems. This optimizer works with pairs of input numbers that
are calculated as unqiue permutations.
In order for this solver to be used solve and difference must be implemented
in the superclass.
"""
def __init__(self, combinations, results = 20):
"""
Initialize the solver with a list of possible combinations to permutate
through.
Example usage:
.. code-block:: python
solver = Solver([1, 2, 3, 4, 5, 6])
solver.solve()
:param combinations: list of possible inputs for the solver to be
compiled into a unique permutations list.
:type combinations: list
"""
self._total_results = results
self._minimum = None
self._maximum = None
self.results = []
self.combinations = combinations
@property
def total_results(self) -> int:
"""
Get the total number of results the solver will return.
:return: number of results solver will return.
:rtype: int
"""
return self._total_results
@total_results.setter
def total_results(self, results) -> int:
"""
Set the total number of results the solver will return.
:param results: number of results to return.
:type results: int
"""
self._total_results = results
@property
def minimum(self):
"""
Get the solver minimum value to consider. Includes bound logic if unset.
:return: minimum value to use in calculations.
:rtype: float
"""
if self._minimum is None:
return 0
return self._minimum
@minimum.setter
def minimum(self, minimum):
"""
Set the minimum value for the solver to consider in calculations.
:param minimum: minimum value to consider in solver calculations.
:type minimum: float
"""
self._minimum = minimum
@property
def maximum(self):
"""
Get the solver maximum value to consider. Includes bound logic if unset.
:return: maximum value to use in calculuations.
:rtype: float
"""
if self._maximum is None:
return float('inf')
return self._maximum
@maximum.setter
def maximum(self, maximum):
"""
Set the maximum value for the solver to consider in calculations.
:param maximum: maximum value to consider in calculations.
:type maximum: float
"""
self._maximum = maximum
#Subclass function to generate the delta to minimize
def difference(self, value, comparison):
raise NotImplementedError("Function needs to be implemented by subclass!")
#Generate all possible unique permutations from input list
def permutations(self, combinations):
"""
Generate a list of all unique combinations for use in the solver. This
prevents the solver from calculating with the same numbers.
:param combinations: list of all combinations to consider in the solver.
:type combinations: list
:return: List of unique combinations.
:rtype: list
Example usage:
.. code-block:: python
solver = Solver([1,2,3,4])
solver.permutations([1,2,3,4])
"""
unique_combinations = set()
for pair in itertools.permutations(combinations, 2):
unique_combinations.add(pair)
return unique_combinations
#External solver to allow for recalculation of target
def solve(self, target):
raise NotImplementedError("Function needs to be implemented by subclass!")
#Internal solve function to be called by solve function
def _solve(self, target):
"""
Internal solver method. This method should be called by the over-ridden
solve() method in the sublcass to engage the solver.
:param target: target setpoint for the optimization algorithm.
:type target: float
:return: calculated values (param 1, param2, difference)
:rtype: list
"""
return self.calculate(self.combinations, target)
#Primary calculation calculation optimization solver
def calculate(self, combinations, target):
"""
Optimization algorithm to calculate the optimum parameters.
:param combinations: list of unique combinations to try to calculate with.
:type combinations: list
:param target: target setpoint for the calculation solver.
:type target: float
"""
unique_combinations = self.permutations(combinations)
for pair in unique_combinations:
x1, x2 = pair
difference = self.difference([x1, x2], target)
#todo: bounds minimum, bounds maximum, bounds sum and difference?
if (min(x1, x2) >= self.minimum) and (max(x1, x2) <= self.maximum):
self.results.append((x1, x2, difference))
ranked_results = sorted(self.results, key=lambda x: x[2])
top_results = ranked_results[:self.total_results]
return top_results
class VoltageDividerSolver(Solver):
"""
Voltage divider solver utilizing the Solver superclass.
Example usage:
.. code-block:: python
>>> possible_resistors = preferred_values('E192')
>>> divider = VoltageDividerSolver(possible_resistors)
>>> divider.total_results = 3
>>> divider.minimum = 1000
>>> divider.maximum = 10000
>>> print(divider.solve(3.578))
[(5620.0, 2180.0, 1.4332602370492609e-06),\
(3970.0, 1540.0, 6.086803910565486e-06),\
(8250.0, 3200.0, 9.763694191367023e-06)]
"""
#The primary function for the solver to use to calculate
def difference(self, value, comparison):
"""
Calculate the difference in the ratio of a voltage divider.
This method calculates the ratio of two resistors in a voltage divider,
then compares it to the comparison ratio.
:param value: list input value for resistors [R1, R2].
:type value: list
:return: difference between the calculated ratio
and the comparison ratio.
:rtype: float
"""
r1, r2 = value
ratio = r2 / (r1 + r2)
difference = abs(comparison - ratio)
return difference
#Add logic to the target
def solve(self, target):
"""
Adds additional functionality to the Solver superclass. For voltage
dividers the ratio is always less than one since dividers can only
provide attenuation, not gain. Therefore, we invert the number if
it is greater than 1.
:param target: input resistor divider ratio
:type target: float
:return: calculated solver output
:rtype: list
"""
if target > 1:
target = 1/target
return self._solve(target)
# Example usage:
if __name__ == "__main__":
resistor_list = preferred_values('E192')
divider = VoltageDividerSolver(resistor_list)
divider.total_results = 25
divider.minimum = 1000
divider.maximum = 10000
values = divider.solve(1.2381237)
for solution in values:
print(solution)
Summary
Voltage dividers are simple yet essential circuits used to scale input voltages. They operate based on the resistor ratios and are inherently passive, meaning they cannot provide gain. Understanding their behavior requires considering tolerance effects, loading impacts, thermal variations, and derating for long-term stability.
Key factors in voltage divider design include:
- Tolerance & Manufacturing Variations – Resistors deviate from nominal values, affecting precision.
- Loading Effects – Any connected load alters the output voltage, requiring careful impedance considerations.
- Thermal Effects – Temperature changes impact resistance, influenced by self-heating and ambient conditions.
- Derating & Long-Term Stability – Components should be operated within safe margins to ensure reliability.
Careful selection of resistor values, combined with analysis techniques like Monte Carlo simulations, ensures that the voltage divider performs as expected under real-world conditions.