Home │ Audio
Home Page 
Copyright © 2013 by Wayne Stegall
Updated December 9, 2015. See Document History at end for
details.
Figure
1:
Current
Limiter 
(1) 
I_{LIMIT} = 
V_{T}
R_{S} 
Figure
2:
Voltage
Limiter 
(2) 
V_{LIMIT} = 
R_{1} + R_{2}
R_{1} 
× V_{T} 
Figure
3:
Amplified
diode 
Figure
4:
Safearea
Limiter 
Figure
5:
Specified
loadline
and
power
limit
boundaries 
Legend: — load line — power limit 
Figure
6:
Illustration
of
a
parallel
limit
line
positioned
for
maximum
power 
Legend: — load line — power limit — limit line 
Figure
7:
Illustration
of
a
limit
more
likely
to
activate
at
peak
signal 
Legend: — load line — power limit — limit line 
(3) 
k_{v}V_{DS} + k_{i}I_{DS} = V_{T} 
(4) 
V_{DS} = 
V_{T}
 k_{i}I_{DS}
k_{v} 
_{ = }  V_{T}
k_{v} 
–  k_{i}
k_{v} 
I_{DS} 
(5) 
P = I_{DS}V_{DS} = I_{DS}  _{ }  V_{T}
k_{v} 
–  k_{i}
k_{v} 
I_{DS} 
(6) 
P = –  k_{i}
k_{v} 
I_{DS}^{2}  +  V_{T}
k_{v} 
I_{DS} 
(7) 
dP dI_{DS} 
= –  2k_{i}
k_{v} 
I_{DS}  +  V_{T}
k_{v} 
= 0 
(8) 
2k_{i}
k_{v} 
I_{DS}  =  V_{T}
k_{v} 
(9) 
I_{DS}  =  V_{T}
2k_{i} 
(10) 
P_{MAX} = 
V_{T}
k_{v} 
V_{T}
2k_{i} 
–  k_{i}
k_{v} 
V_{T}
2k_{i} 
^{2} 
(11) 
P_{MAX} = 
V_{T}^{2}
2k_{v}k_{i} 
–  k_{i}V_{T}^{2}
4k_{v}k_{i}^{2} 
=  V_{T}^{2}
2k_{v}k_{i} 
– 
V_{T}^{2}
4k_{v}k_{i} 
(12) 
P_{MAX} = 
V_{T}^{2}
4k_{v}k_{i} 
If Z_{LIM} =  
k_{i}
k_{v} 
, then k_{i} = Z_{LIM}k_{v} 
(13) 
P_{MAX} = 
V_{T}^{2}
4Z_{LIM}k_{v}^{2} 
(14) 
k_{v} = 

(15) 
k_{v} =  R_{1}  R_{3}
(R_{1}  R_{3}) + R_{2} 
(16) 
k_{i} =  R_{1}  R_{2}
(R_{1}  R_{2}) + R_{3} 
(17) 

V_{D} + 
R_{1}  R_{2}
(R_{1}  R_{2}) + R_{3} 
I_{DS} = V_{T} 
(18) 
(R_{1}  R_{3}) + R_{2} =  R_{1}  R_{3}
k_{v} 
(19) 
R_{2} =  R_{1}  R_{3}
k_{v} 
– (R_{1}  R_{3}) 
(20) 
(R_{1}  R_{2}) + R_{3} =  R_{1}  R_{2}
k_{i} 
(21) 
R_{3} =  R_{1}  R_{2}
k_{i} 
– (R_{1}  R_{2}) 
Figure
8:
C++
code
for
calculating
safearea
limiter
component
values 
/* sal.cpp  prove the equations calculated to define a singleslope safe area limiter. */ #include <iostream> #include <cmath> using namespace std; #define PAR(x,y) ((x)*(y)/((x)+(y))) /* If convergence is at least as good as binary, iterations equal to the number of bits in the mantissa of a double are sure to produce double accuracy */ #define ITER 52 int main(void) { int i; double zlim, pmax, kv, ki, vt; double r1, r2, r3, rs, rtmp; double vmax, imax; // input values zlim = 8.0; pmax = 300.0; r1 = 68.0; rs = 0.1; vt = 0.763; // calculate limit line specifications kv = sqrt((vt*vt)/(4.0*zlim*pmax)); ki = kv*zlim; vmax = vt/kv; imax = vt/ki; // calculate component values r2 = r1; r3 = r1; for(i=0;i<ITER;i++) { rtmp = PAR(r1,r3); r2 = (rtmp/kv)rtmp; rtmp = PAR(r1,r2); r3 = (rs*rtmp/ki)rtmp; // watch results for convergence cout << "R2 = " << r2 << ",\t" << "R3 = " << r3 << endl; } // print remaining results cout << "Seed values:" << endl; cout << "R1 = " << r1 << ",\t" << "RS = " << rs << endl; cout << "VT = " << vt << ",\t" << "PMAX = " << pmax; cout << ",\t" << "ZLIM = " << zlim << endl; cout << "Endpoints: " << vmax << "V,\t" << imax << "A" << endl; return 0; } 
Figure 9: Program output for parameters given 
R2 =
4332.06, R3 = 40.5156 R2 = 3234.86, R3 = 40.3043 R2 = 3224.26, R3 = 40.3016 ... R2 = 3224.13, R3 = 40.3016 Seed values: R1 = 68, RS = 0.1 VT = 0.763, PMAX = 300, ZLIM = 8 Endpoints: 97.9796V, 12.2474A 
Figure
10:
Illustration
of
a
limit
more
likely
to
activate
at
peak
signal 
SPICE model 
Figure
11:
An
opamp
model
of
limit
line
only.: 
(22) 
V_{D} = –  R_{2}
R_{3} 
(R_{S}I_{DS}–V_{T}) –  R_{2}
R_{1} 
(0–V_{T}) + V_{T} 
(23) 
V_{D} = –  R_{2}R_{S}
R_{3} 
I_{DS} +  R_{2}
R_{3} 
_{+ }  R_{2}
R_{1} 
+ 1 
V_{T} 
(24) 
Z_{LIM} = –  R_{2}R_{S}
R_{3} 
(25) 
I_{R1} = –  V_{D}–V_{T}
R_{2} 
+  R_{S}I_{DS}–V_{T}
R_{3} 
_{ = }  V_{T}
R_{1} 
(26) 
R_{1} = 

(27) 
R_{1} = 

Figure
12:
C++
code
for simpler calculations of safearea
limiter
component
values. 
/* sal2.cpp  prove the equations calculated to define a singleslope safe area limiter. */ #include <iostream> #include <cmath> using namespace std; #define PAR(x,y) ((x)*(y)/((x)+(y))) int main(void) { double zlim, pmax, kv, ki, vt; double r1, r2, r3, rs; double vmax, imax; // input values zlim = 8.0; pmax = 300.0; //r1 = 68.0; r3 = 40.3016; rs = 0.1; vt = 0.763; // calculate limit line specifications kv = sqrt((vt*vt)/(4.0*zlim*pmax)); ki = kv*zlim; vmax = vt/kv; imax = vt/ki; // calculate component values r2 = zlim*r3/rs; // calculate r1 at midpoint //r1 = vt/(((0.5*vmax)vt)/r2+(rs*(0.5*imax)vt)/r3); // calculate r1 at voltage endpoint r1 = vt/((vmaxvt)/r2  vt/r3); // print results cout << "R2 = " << r2 << ",\t" << "R3 = " << r3 << endl; cout << "Seed values:" << endl; cout << "R1 = " << r1 << ",\t" << "RS = " << rs << endl; cout << "VT = " << vt << ",\t" << "PMAX = " << pmax; cout << ",\t" << "ZLIM = " << zlim << endl; cout << "Endpoints: " << vmax << "V,\t" << imax << "A" << endl; return 0; } 
Figure 13: Program output for parameters given 
R2 = 3224.13,
R3 = 40.3016 Seed values: R1 = 68, RS = 0.1 VT = 0.763, PMAX = 300, ZLIM = 8 Endpoints: 97.9796V, 12.2474A 
(12) 
P_{MAX} = 
V_{T}^{2}
4k_{v}k_{i} 
If Z_{LIM} =  
k_{i}
k_{v} 
, then k_{v} = 
k_{i}
Z_{LIM} 
(28) 
P_{MAX} = 
Z_{LIM}V_{T}^{2}
4k_{i}^{2} 
(29) 
Z_{LIM} = 
4k_{i}^{2}P_{MAX}
V_{T}^{2} 
(30)  I_{MAX} = 
V_{T}
k_{i} 
, therefore k_{i} =

V_{T}
I_{MAX} 
(31)  P_{MAX} =  Z_{LIM}V_{T}^{2}
4 
× 
I_{MAX}^{2}
V_{T}^{2} 
(32)  P_{MAX} =  Z_{LIM} × I_{MAX}^{2}
4 
(33)  Z_{LIM} =  4P_{MAX}
I_{MAX}^{2} 
Figure 14: C++ code for
calculation of safearea limiter component values from power and
current limit specifications. 
/* sal3.cpp  prove the equations calculated to define a singleslope safe area limiter. */ #include <iostream> #include <cmath> using namespace std; #define PAR(x,y) ((x)*(y)/((x)+(y))) int main(void) { double zlim, pmax, kv, ki, vt; double r1, r2, r3, rs; double vmax, imax; // input values imax = 10.0; pmax = 300.0; r3 = 47; rs = 0.1; vt = 0.763; // calculate limit line specifications zlim = 4*pmax/(imax*imax); // remaining limit line specifications are informational // and not necessary to finish calculations kv = sqrt((vt*vt)/(4.0*zlim*pmax)); ki = vt/imax; kv = ki/zlim; vmax = vt/kv; // calculate component values r2 = zlim*r3/rs; // calculate r1 at midpoint //r1 = vt/(((0.5*vmax)vt)/r2+(rs*(0.5*imax)vt)/r3); // calculate r1 at current endpoint r1 = vt/((vt)/r2+(rs*imaxvt)/r3); // print results cout << "R2 = " << r2 << ",\t" << "R3 = " << r3 << endl; cout << "R1 = " << r1 << ",\t" << "RS = " << rs << endl; cout << "VT = " << vt << ",\t" << "PMAX = " << pmax; cout << ",\t" << "ZLIM = " << zlim << endl; cout << "Endpoints: " << vmax << "V,\t" << imax << "A" << endl; return 0; } 
Figure 15: Program output for parameters given 
R2 = 5640, R3
= 47 R1 = 155.484, RS = 0.1 VT = 0.763, PMAX = 300, ZLIM = 12 Endpoints: 120V, 10A 
Figure
16:
SPICE
plot
of
resulting
load
line 
SPICE model 

Document History
March 16, 2013 Created.
April 5, 2013 Added an improved component calculation sequence
and additional power calculations.
December 9, 2015 Corrected two misspellings.