Can I Realize 0.1% Tolerance with 3 Parallel Resistors?

[bobledoux]

I have read that by using three parallel resistors I can realize 0.1% tolerance within any desired value. Does anyone have an algorithm for doing this?

 

[ronsimpson]

Are you using +/-0.1% resistors?
I am trying to decide what you mean by tolerance.
By paralleling resistors you can get values you have never seen before.
Example. 10k//12k=5.45k but if the resistors are 5% tolerance then the 5.45k resistance is also 5%.
Maybe you are thinking of resolution. You can get 4.7k, 5.2k and 5.6k but you can not get 5.45k

 

[crutschow]

You can get the resistor precision value very close to an arbitrary resistance value by series or parallel combining two 1% resistors but the overall accuracy is still only 1%. Here's a program to do that.

 

[bobledoux]

I am working on all pass active filters in a phase delay network. I will measure individual resistors to within 0.1%. If I assume "perfect value" components is there an algorithm that allows me to combine three resistors in parallel to achieve 0.1% error? It can be done with series resistors because they add together. For example, if I want 505 ohms I can series 470+33+2. Can I achieve the same result using parallel resistors.

In SMT construction it is easy to put down 2 parallel pads on which components can be mounted. If series pads are used more space is required and 0ohm components are needed for unused pads.

 

[bobledoux]

crutschow, that is a good link. IN0TD (a Ham call) starts with the resistor series and calculates the possible combinations. His calculator is limited to two parallel resistors. The possible combinations with three parallel resistors might make his approach unreasonable.

My questions started because I read an unsupported statement that by combining three resistors in parallel, one could achieve any resistor value within 0.1%. This statement assumes "perfect value" components and disregards aging and other factors.

If such tolerances are required, one could progressively measure a component and calculate the required value for the next, and so forth. In the end, a series of resistors ending with a low value trimmer might be the best way to go.

 

[alec_t]

Which resistor series do you have available? E96, E192?

 

[bobledoux]

Assume E24 (5%).

 

[dougy83]

I just wrote some code to do this:

#include <iomanip>
#include <iostream>
#include <cstdlib>
#include <cmath>
#include <vector>

using namespace std;

void usage()
{
    cout <<
    "Usage: calcres.exe <resval> <numres> <s/p>" << endl <<
    "Where: <resval> is the desired resistance" << endl <<
    "       <numres> is the number of resistors to use" << endl <<
    "       <s/p>    is 's' to use series resistors, or 'p' to use parallel resistors" << endl;
}

float e[25] = {1.0, 1.2, 1.5, 1.8, 2.2, 2.7, 3.3, 3.9, 4.7, 5.6, 6.8, 8.2, 1.1, 1.3, 1.6, 2.0, 2.4, 3.0, 3.6, 4.3, 5.1, 6.2, 7.5, 9.1, 10};

void getParallel(float target, int nres, vector<float> &current, float currentRecipSum, vector<float> &best, float &bestValue)
{
    if(fabs(bestValue - target) / target < 0.001)               // 0.1% error is acceptable
        return;

    if(currentRecipSum > 0 && 1/currentRecipSum < bestValue)    // early-out for aimless checks
        return;
     
    for(float decade = 0.001; decade <= 1000000; decade *= 10)
    {
        if(decade * 10 < bestValue)    // early-out for aimless checks
            continue;

        for(int i = 0; i < 25; i++)
        {          
            if(current.size() == nres - 1)
            {
                float val = 1 / (1/(decade*e[i]) + currentRecipSum);

                if(fabs(val - target) < fabs(bestValue - target))
                {
                    bestValue = val;
                    best = current;
                    best.push_back(decade*e[i]);
                 
                    if(fabs(bestValue - target) / target < 0.001)
                        return;
                }
            }
            else
            {              
                current.push_back(decade*e[i]);
                getParallel(target, nres, current, currentRecipSum + 1/(decade*e[i]), best, bestValue);
                current.pop_back();
            }
        }
    }
}

int main(int argc, char **argv)
{
    if(argc != 4)
    {
        usage();          
        return -1;
    }
 
   float target = atof(argv[1]);
   int nres = atoi(argv[2]);
   char sp = argv[3][0];
 
   if(target <= 0 || nres <= 0 || (sp != 's' && sp != 'p'))
   {
       usage();
       return -1;
   }
 
   if(sp == 'p')
   {
        vector<float> best, current;
        float bestValue = 0;
        getParallel(target, nres, current, 0, best, bestValue);
     
        for(int i = 0; i < best.size(); i++)
            cout << "Resistor " << (i+1) << ": \t" << best[i] << endl;
         
        cout << "Parallel total: " << bestValue << endl;
        cout << "Error: " << setprecision(2) << ( (bestValue - target) / target * 100 ) << "%" << endl;
    } 
    else
    {
        cout << "Series calculation not implemented" << endl;
    }

   return 0;
}

You can run it online here: http://www.compileonline.com/compile_cpp_online.php
Example output when calculating parallel combination of two resistors to get an equivalent 4684 ohm resistor:

Compiling the source code....
$g++ main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1

Executing the program....
$demo 4684 2 p
Resistor 1: 6800
Resistor 2: 15000
Parallel total: 4678.9
Error: -0.11%

 

[crutschow]

Assume E24 (5%).

5% resistors would likely have poor temperature stability, making connecting them to meet a 0.1% requirement problematic. At a minimum you should use 1% resistors.

 

[KeepItSimpleStupid]

I can't find them anymore, but there was a "Rejuster" technology. See https://www.electronicproducts.com/.../Adjustable_resistor_tunes_TCR_passively.aspx

I remember the website, etc.

 

[KeepItSimpleStupid]

I found a datasheet, but no company: https://www.google.com/url?sa=t&rct...aGW9PJO_i5miooQ&bvm=bv.79189006,d.aWw&cad=rja

 

[MrAl]

Hello,

The best way to parallel resistors in order to obtain a more precise value is to tune the parallel combination right in the end application. Alternately, use an ohm meter to measure the resistance and tune as needed. Might need more than three resistors.

But why limit it to 3 in parallel, how about 1 in parallel with 2 in series? Maybe some advantage.