ת'אוונין ונורטון

לחץ או הקש על מעגלי הדוגמה שלהלן כדי להפעיל את TINACloud ובחר במצב DC אינטראקטיבי כדי לנתח אותם באופן מקוון.
קבל גישה נמוכה עלות TINACloud כדי לערוך את הדוגמאות או ליצור מעגלים משלך

משפט תיאוונין למעגלי זרם חילופין עם מקורות סינוסואידים דומה מאוד למשפט שלמדנו עבור מעגלי DC. ההבדל היחיד הוא שעלינו לקחת בחשבון עכבה במקום התנגדות. בתמציתיות, משפט תעבנין למעגלי AC אומר:

ניתן להחליף כל שני מעגלים לינאריים מסופים במעגל שווה המורכב ממקור מתח (VTh) ועכבה סדרתית (ZTh).

במילים אחרות, משפט תאוונין מאפשר להחליף מעגל מסובך במעגל שווה ערך המכיל רק מקור מתח ועכבה מחוברת סדרה. המשפט חשוב מאוד גם מבחינה תיאורטית וגם מבחינה מעשית.

חשוב לציין כי המעגל המקביל לת'אבנין מספק שקילות במסופים בלבד. ברור שהמבנה הפנימי של המעגל המקורי ושווה ערך הת'אוונין עשויים להיות שונים למדי. ולמעגלי זרם חילופין, שבהם עכבה תלויה בתדר, השוויון תקף ב אחד תדירות בלבד.

שימוש במשפט של תעבנין מועיל במיוחד כאשר:

· אנו רוצים להתרכז בחלק מסוים במעגל. את שאר המעגל אפשר להחליף במקבילה פשוטה של ​​תווינין.

· עלינו ללמוד את המעגל עם ערכי עומס שונים במסופים. באמצעות המקבילה של ת'אוונין אנו יכולים להימנע מלהצטרך לנתח את המעגל המקורי המורכב בכל פעם.

אנו יכולים לחשב את המעגל המקביל לת'אבין בשני שלבים:

1. לחשב ZTh. הגדר את כל המקורות לאפס (החלף מקורות מתח על ידי מעגלים קצרים ומקורות זרם על ידי מעגלים פתוחים) ואז מצא את העכבה הכוללת בין שני המסופים.

2. לחשב Vת. מצא את מתח המעגל הפתוח בין המסופים.

משפט נורטון, שהוצג כבר עבור מעגלי DC, יכול לשמש גם במעגלי AC. משפט נורטון שהוחל על מעגלי AC קובע כי ניתן להחליף את הרשת באמצעות מקור נוכחי במקביל ל- עכבה.

אנו יכולים לחשב את המעגל המקביל לנורטון בשני שלבים:

1. לחשב ZTh. הגדר את כל המקורות לאפס (החלף מקורות מתח על ידי מעגלים קצרים ומקורות זרם על ידי מעגלים פתוחים) ואז מצא את העכבה הכוללת בין שני המסופים.

2. לחשב Iת. מצא את זרם הקצר בין המסופים.

בואו נראה כמה דוגמאות פשוטות.

דוגמה 1

מצא את המקבילה של הת'עוין לרשת עבור הנקודות A ו- B בתדירות: f = 1 kHz, vS(T) = 10 cosw ×t V.


לחץ / הקש על המעגל שלמעלה כדי לנתח באינטרנט או לחץ על קישור זה כדי לשמור תחת Windows

השלב הראשון הוא למצוא את מתח המעגל הפתוח בין נקודות A ו- B:

מתח המעגל הפתוח באמצעות חלוקת מתח:

= -0.065 - j2.462 = 2.463 ה-J91.5º V

בודק עם TINA:


השלב השני הוא להחליף את מקור המתח במעגל קצר ולמצוא את העכבה בין נקודות A ו- B:

כמובן שאנחנו יכולים לבדוק את ה- Z שלנוT פתרון באמצעות מד העכבה של TINA (שימו לב שהחלפנו את מקור המתח בקצר):


הנה המעגל המקביל של תוונין, תקף רק בתדר של 1kHz. ראשית, עלינו לפתור את הקיבולת של CT. שימוש במערכת היחסים 1 /wCT = 304 ohm, אנו מוצאים CT = 0.524 uF

כעת יש לנו את הפיתרון: RT = 301 אוהם ו- CT = 0.524 m F:

לאחר מכן נוכל להשתמש במתורגמן של TINA כדי לבדוק את החישובים שלנו לגבי המעגל המקביל לשווין:

{פיתרון של המתורגמן של TINA}
VM: = 10;
f: = 1000;
om: = 2 * pi * f;
Z1: = R1 + j * om * L;
Z2: = R2 / (1 + j * om * C * R2);
VT: = VM * Z2 / (Z1 + Z2);
VT = [- 64.0391m-2.462 * j]
ABS (VT) = [2.4629]
ABS (VT) / sqrt (2) = [1.7415]
radtodeg (arc (VT)) = [- 91.49]
ZT: = Replus ((R1 + j * om * L), החזרה (R2, (1 / j / om / C));
ZT = [301.7035-303.4914 * j]
Abs (ZT) = [427.9393]
radtodeg (arc (ZT)) = [- 45.1693]
Ct: = - 1 / im (ZT) / om;
Ct = [524.4134n]
#פתרון מאת פייתון!
ייבוא ​​מתמטיקה בתור m
ייבוא ​​cmath כמו c
#בואו לפשט את ההדפסה של מורכבות
#numbers לשקיפות רבה יותר:
cp= lambda Z : "{:.4f}".format(Z)
#הגדר ריפלוס באמצעות למבדה:
Replus= lambda R1, R2 : R1*R2/(R1+R2)
VM=10
f = 1000
om=2*c.pi*f
Z1=complex(R1,om*L)
Z2=R2/complex(1,om*C*R2)
VT=VM*Z2/(Z1+Z2)
print(“VT=”,cp(VT))
print("abs(VT)= %.4f"%abs(VT))
print("abs(VT)/sqrt(VT)= %.4f"%(abs(VT)/m.sqrt(2)))
print("degrees(arc(VT))= %.4f"%m.degrees(c.phase(VT)))
ZT=Replus(complex(R1,om*L),Replus(R2,1/1j/om/C))
print(“ZT=”,cp(ZT))
print(“abs(ZT)= %.4f”%abs(ZT))
print("degrees(arc(ZT))= %.4f"%m.degrees(c.phase(ZT)))
Ct=-1/ZT.imag/om
print(“Ct=”,Ct)

שים לב שברישום שלמעלה השתמשנו בפונקציה "replus". Replus פותר את המקבילה המקבילה לשתי עכבות; כלומר, הוא מוצא את המוצר מעל סכום שתי העכבות המקבילות.

דוגמה 2

מצא את המקבילה של נורטון למעגל בדוגמה 1.

f = 1 kHz, vS(T) = 10 cosw ×t V.


לחץ / הקש על המעגל שלמעלה כדי לנתח באינטרנט או לחץ על קישור זה כדי לשמור תחת Windows

עכבת המקבילה זהה:

ZN= (0.301-j0.304) קW

בשלב הבא, מצא את זרם הקצר:

IN = (3.97-j4.16) mA

ונוכל לבדוק את חישובי הידיים שלנו מול תוצאות TINA. ראשית עכבת המעגל הפתוח:


ואז זרם הקצר:


ולבסוף המקבילה לנורטון:

בשלב הבא נוכל להשתמש במתורגמן של TINA כדי למצוא את רכיבי המעגל המקבילים לנורטון:

{פיתרון של המתורגמן של TINA}
VM: = 10;
f: = 1000;
om: = 2 * pi * f;
Z1: = R1 + j * om * L;
Z2: = R2 / (1 + j * om * C * R2);
IN: = VM / Z1;
IN = [3.9746m-4.1622m * j]
ABS (IN) = [5.7552m]
ABS (IN) / sqrt (2) = [4.0695m]
radtodeg (arc (IN)) = [- 46.3207]
ZN: = Replus ((R1 + j * om * L), החזרה (R2, (1 / j / om / C));
ZN = [301.7035-303.4914 * j]
Abs (ZN) = [427.9393]
radtodeg (arc (ZN)) = [- 45.1693]
CN: = - 1 / im (ZN) / om;
CN = [524.4134n]
#פתרון מאת פייתון!
ייבוא ​​מתמטיקה בתור m
ייבוא ​​cmath כמו c
#בואו לפשט את ההדפסה של מורכבות
#numbers לשקיפות רבה יותר:
cp= lambda Z : "{:.4f}".format(Z)
#הגדר ריפלוס באמצעות למבדה:
Replus= lambda R1, R2 : R1*R2/(R1+R2)
VM=10
f = 1000
om=2*c.pi*f
Z1=complex(R1,om*L)
Z2=R2/complex(1,om*C*R2)
IN=VM/Z1
print(“IN=”,cp(IN))
print(“abs(IN)= %.4f”%abs(IN))
print("degrees(arc(IN))= %.4f"%m.degrees(c.phase(IN)))
print("abs(IN)/sqrt(2)= %.4f"%(abs(IN)/m.sqrt(2)))
ZN=Replus(complex(R1,om*L),Replus(R2,1/1j/om/C))
print(“ZN=”,cp(ZN))
print(“abs(ZN)= %.4f”%abs(ZN))
print("degrees(arc(ZN))= %.4f"%m.degrees(c.phase(ZN)))
CN=-1/ZN.imag/om
print(“CN=”,CN)

דוגמה 3

במעגל זה העומס הוא RL ו- CL המחוברים בסדרה. רכיבי עומס אלה אינם חלק מהמעגל אשר מקבילנו אנו מחפשים. מצא את הזרם בעומס באמצעות המקבילה של נורטון של המעגל.

v1(t) = 10 cos wt V; v2(t) = 20 cos (wt + 30°) אשר; v3(t) = 30 cos (wt + 70°) אשר;

v4(t) = 15 cos (wt + 45°) אשר; v5(t) = 25 cos (wt + 50°) אשר; f = 1 kHz.


לחץ / הקש על המעגל שלמעלה כדי לנתח באינטרנט או לחץ על קישור זה כדי לשמור תחת Windows

ראשית מצא את עכבת המעגל הפתוח מקבילה Zeq (ללא העומס).

מבחינה מספרית

ZN = Zeq = (13.93 - j5.85) אוהם.

להלן נראה הפיתרון של TINA. שים לב שהחלפנו את כל מקורות המתח בקצרים לפני שהשתמשנו במונה.


עכשיו זרם הקצר:

חישוב זרם הקצר הוא די מסובך. רמז: זו תהיה זמן טוב להשתמש ב- Superposition. גישה תהיה למצוא את זרם העומס (בצורה מלבנית) עבור כל מקור מתח שנלקח אחד בכל פעם. ואז סיכמו את חמש התוצאות החלקיות כדי לקבל את הסכום.

אנו פשוט נשתמש בערך המסופק על ידי TINA:

iN(t) = 2.77 cos (w ×האם 118.27°)


מחבר את הכל יחד (החלפת הרשת במקבילה של נורטון, חיבור מחדש של רכיבי העומס לפלט והכנסת מד זרם בעומס), יש לנו את הפיתרון לזרם העומס שחיפשנו:


על ידי חישוב ידני, נוכל למצוא את זרם העומס באמצעות חלוקה נוכחית:

בסופו של דבר

I = (- 0.544 - j 1.41) א

ואת הפונקציה הזמן

i (t) = 1.51 cos (w ×t - 111.1°)

{פיתרון של המתורגמן של TINA}
{השיטה המקוצרת על ידי זרם רשת}
om: = 2000 * pi;
V1: = 10;
V2:=20*exp(j*pi/6);
V3:=30*exp(j*pi/18*7);
V4:=15*exp(j*pi/4);
V5:=25*exp(j*pi/18*5);
Sys J1,J2,J3,J4
J1*(R-j*2/om/C)+V1+J2*j/om/C+J3*j/om/C=0
J1*j/om/C+J2*(j*om*L-j/om/C)+V4-V2=0
J1*j/om/C+J3*(R+j*om*L-j/om/C)-J4*j*om*L+V3+V5-V4=0
-J3*j*om*L+J4*(R+j*om*L)-V3=0
הסוף;
J3=[-1.3109E0-2.4375E0*j]
{העכבה של הרשת ה'הרוגה'}
ZLC:=j*om*L/(1-sqr(om)*L*C);
ZRL:=j*om*L*R/(R+j*om*L);
ZN:=(R+ZLC)/(1+j*om*C*(R+ZLC))+R+ZRL;
ZN=[1.3923E1-5.8456E0*j]
I:=J3*ZN/(ZN+RL-j/om/C);
I=[-5.4381E-1-1.4121E0*j]
#פתרון מאת פייתון!
ייבוא ​​מתמטיקה בתור m
ייבוא ​​cmath כמו c
#בואו לפשט את ההדפסה של מורכבות
#numbers לשקיפות רבה יותר:
cp= lambda Z : "{:.4f}".format(Z)
om=2000*c.pi
V1=10
V2=20*c.exp(1j*c.pi/6)
V3=30*c.exp(1j*c.pi/18*7)
V4=15*c.exp(1j*c.pi/4)
V5=25*c.exp(1j*c.pi/18*5)
#יש לנו מערכת משוואות לינארית
#שאנחנו רוצים לפתור עבור J1,J2,J3,J4:
#J1*(R-j*2/om/C)+V1+J2*j/om/C+J3*j/om/C=0
#J1*j/om/C+J2*(j*om*L-j/om/C)+V4-V2=0
#J1*j/om/C+J3*(R+j*om*L-j/om/C)-J4*j*om*L+V3+V5-V4=0
#-J3*j*om*L+J4*(R+j*om*L)-V3=0
ייבוא ​​numpy בתור n
#כתוב את המטריצה ​​של המקדמים:
A=n.array([[complex(R,-2/om/C),1j/om/C,1j/om/C,0],
[1j/om/C,1j*om*L-1j/om/C,0,0],
[1j/om/C,0,R+1j*om*L-1j/om/C,-1j*om*L],
[0,0,-1j*om*L,R+1j*om*L]])
b=n.array([-V1,V2-V4,V4-V3-V5,V3])
J1,J2,J3,J4=n.linalg.solve(A,b)
print(“J3=”,cp(J3))
#העכבה של הרשת ה'הרוגה'
ZLC=1j*om*L/(1-om**2*L*C)
ZRL=1j*om*L*R/(R+1j*om*L)
ZN=(R+ZLC)/(1+1j*om*C*(R+ZLC))+R+ZRL
print(“ZN=”,cp(ZN))
I=J3*ZN/(ZN+RL-1j/om/C)
print(“I=”,cp(I))