הצגת המקור של מחולל אותות

[[File:Agilent33220A.jpg|thumb|450px|left|<figure id="fig:awg"><caption>Keysight 33220A 20 MHz Function/Arbitrary Waveform Generator</caption></figure>]]
= מידע כללי =
'''מחולל אותות''' (בלועזית '''Function Generator''' - ראו [[#הערות|הערות]]) של חברת [http://www.keysight.com/ Keysight], לשעבר Agilent.

במעבדה קיים דגם [{{manuals}}/Agilent%2033220A.pdf Agilent 33220A] כפי שרואים ב<xr id="fig:awg"/>, כשמו כן הוא - תפקידו לחולל אותות.

למידע נוסף ניתן לפנות ל[[נספח הכרת מכשירי מדידה חלק א#מחולל אותות (Waveform Generator)|נספח]].

*ניתן לשלוט על צורת האות, בעיקר:
*# גל סינוס (הכפתור הדלוק בתמונה).
*# גל מרובע, עם [[wikipedia:he:דיוטי סייקל|Duty Cycle]] של בין 20% ל-80% (בשביל ערכים קיצוניים יותר ניתן להשתמש בפונקציית Pulse).
*# גל שן-משור - במידה וה-Symmetry מכוון ל-50% יווצר גל-משולש.
* תדר האות, בין 1µHz עד 20MHz בסינוס/מרובע או עד 200kHz בגל שן-מסור/משולש.
* עוצמת המתח, מגיע עד 20Vp-p.
* וכן להוסיף מתח ישר (DC Offset), קיימות שתי אפשרויות:
*# גל AC אשר רוכב על DC.
*# להוציא רק DC ללא AC, כמו ה[[ספק כוח מיוצב]], ע"י לחיצה על כפתור Utility ולאחריו DC On, ניתן להוציא עד &plusmn;5V.

<u>הערה</u>: ניתן להשתמש גם ב[[משקף תנודות]] כדי לחולל אותות ע"י לחיצה על הכפתור/נורה <code>Wave Gen</code> והתחברות ליציאת <code>Gen Out</code>, אך המתח שם מוגבל רק ל-2.5Vp-p או 5Vp-p (עבור התנגדות עומס של 50&Omega; או אינסוף בהתאמה).

= עבודה עם המכשיר =
לפני תחילת העבודה רצוי לאפס את המכשיר למקרה שכיוונו שם אפשרויות אשר לא מוכרות לנו, זאת עושים ע"י:
# לחיצה על כפתור Recall
# לחיצה על הכפתור הרך (במסך) Set to Defaults
# לחיצת אישור על Yes
מיד לאחר פעולה זו יש לזכור כמה דברים:
# כפתור ה-Output כבוי, במצב זה אין מתח מוצא, לכן יש ללחוץ עליו - הוא יידלק בצבע ירוק.
# התנגדות העומס מכוונת ל-50Ω וכיוון שגם התנגדות המוצא של ה'''מחולל''' היא זהה - כל מתח שנכוון יוכפל פי שתיים ע"י ה'''מחולל''' כדי לפצות על חלוקת המתח בעומס, ולכן צריך לכוון את התנגדות העומס ל-High Z ע"י:
#* לחיצה על Utility
#* לחיצה על Output Setup
#* בצד שמאל לבחור High Z במקום Load
# מתח ברירת המחדל הוא רק 100mV, לכן צריך לכוון אותו לפחות ל-1V, במידה ופעולה זו בוצעה לפני הפעולה הקודמת - המתח יוכפל פי 2 ל-2V בהתאם לדוגמא הנוכחית.

= סריקת תדרים =
[[File:RLC.svg|left|thumb|upright=1.5|<figure id="fig:rlc"><caption>תגובה ליניארית לתדר של מעגל RLC</caption>, רואים שכל התדרים הם שווי-ערך מבחינה מספרית למיקום האופקי שהוא למעשה ציר-זמן ולא ציר-תדר ב[[משקף תנודות]]. מעגל זה הוא מעגל RLC מקבילי בהתאם ל[[תופעות מעבר|ניסוי 5]] עם L=1H, C=10nF ו-R=100k&Omega;.</figure>]]
[[File:RC-Linear.svg|left|thumb|upright=1.5|<figure id="fig:rclin"><caption>תגובה ליניארית לתדר של מעגל RC</caption> בה קשה לראות את תדר-הברך כיוון שתחום הסריקה רחב מדי.</figure>]]
[[File:RC-Log.svg|left|thumb|upright=1.5|<figure id="fig:rclog"><caption>תגובה לוגריתמית לתדר של מעגל RC</caption>.<br/><u>הערה חשובה</u>: הנגד כאן הוא רק 159&Omega; (וקבל 1&mu;F) שזהו בערך אותו סדר גודל של ההתנגדות הפנימית של המחולל שהיא 50&Omega; ולכן צריך להתחשב בכך בזמן שמחברים מערך מדידה זה אל ה'''מחולל'''.</figure>]]
מנגנון סריקת-התדרים, נקרא בלועזית [[wikipedia:Radio-frequency sweep|Frequency Sweep]], נועד להוציא מה'''מחולל''' תדר משתנה למקרה שרוצים לבדוק תגובה של מעגל לתדר, כך ניתן לחבר את המעגל ל[[משקף תנודות]] וניתן בצורה אוטומטית לקבל את גרף המתח בתלות בתדר כלומר את תגובת המעגל לתדר. שליטה על מנגנון סריקת התדרים נעשית באופן הבא:
# לוחצים על כפתור SWEEP הכפתור השני משמאל בשורת הכפתורים התחתונה
# כפתור Start קובע את התדר ההתחלתי ממנו מתחילה הסריקה
# כפתור Stop קובע את התדר הסופי בו תסתיים הסריקה ואז התדר ייקפוץ ישר לתדר Start ויתחיל שוב
# כפתור Sweep Time קובע במשך כמה זמן תתבצע כל חזרה של סריקה, הברירת מחדל מכוונת לשנייה כלומר כל שנייה ה'''מחולל''' יוציא תדר המשתנה החל מתדר Start ועד תדר Stop
# כפתור Sweep Mode קובע האם הסריקה תהיה:
#* ליניארית, כלומר האם התדר עצמו ישתנה בצורה ליניארית:
#*# אם נעשה סריקה למשל במשך 3 שניות, בתחום של 1Hz עד 3kHz, כפי שרואים ב<xr id="fig:rlc"/>, נוכל לקרוא את הציר האופקי בצורה ישירה - כל מילי-שנייה תהיה שוות ערך להרץ אחד, או במקרה המסויים הזה - מיקום 1588 מילי-שניות בציר האופקי של ה[[משקף תנודות|סקופ]] ייצג את תדר 1588 הרץ כיוון שזוהי סריקה ליניארית.
#*# אם נעשה סריקה במשך 5 שניות, בין 1 הרץ ל-100kHz, של מעגל RC למשל כפי שרואים ב<xr id="fig:rclin"/> (לקוח מ[[הכרת מכשירי מדידה חלק א#תשובה לתכנון מעגל מסנן מעביר-גבוהים|תשובה לתכנון מעגל מסנן מעביר-גבוהים בדו"ח מכין 1א']]) כאשר תדר הברך הוא 1000 הרץ - לא נצליח לראות טוב את הגרף כיוון שהתדר המעניין כאן הופיע ישר על ההתחלה והוא דחוס בין הרבה מאוד נתונים לא רלוונטים, לכן במקרה זה דרושה סריקה של תחום תדרים יותר צר או סריקה לוגריתמית.
#* לוגריתמית, כלומר האם הלוג של התדר ישתנה בצורה ליניארית:
#*# אם ניקח את אותו המעגל RC מהסריקה הליניארית שראינו ב<xr id="fig:rclin"/> ונעשה לו סריקה לוגריתמית, נקבל את מה שאנו רואים ב<xr id="fig:rclog"/>, הפעם תדר-הברך נמצא במרכז התמונה, אך מצד שני חישוב התדר אינו טריוויאלי כמו בסריקה הליניארית, כדי לדעת את תדר הברך צריך לעשות 10 בחזקת הזמן (במקרה המסויים הזה), כלומר 10 בחזקת 3 נותן 1000 הרץ שזהו תדר הברך.
# כיוון שבסריקת-תדרים התדרים תמיד משתנים זה מאוד קשה להסתנכרן על הגל - הוא תמיד יזוז על ה[[משקף תנודות]] ולכן יש להשתמש במקרה זה ביציאת הסינכרון (Sync ב<xr id="fig:awg"/>), מיציאה זו יוצא גל בעל המאפיינים הבאים:
#* גל-ריבועי.
#* עוצמה בין 0 ל-3.3V.
#* תדר זהה לחלוטין לזמן הסריקה (Sweep Time), אם למשל זמן-הסריקה הוא שנייה - התדר של גל-הסינכרון יהיה 1Hz.
#* המחשה של גל הסינכרון ניתן לראות בערך [[משקף תנודות]] תחת הסעיף [[משקף תנודות#מנגנון הסינכרון של משקף-התנודות|מנגנון הסינכרון]].
<br clear="all"/>

== כלי אינטראקטיבי להבנת מנגנון סריקת-התדרים ==
להלן כלי הִדּוּדִי (אינטראקטיבי) להבנה מעמיקה של קריאת ציר לוגריתמי / ליניארי.

=== גליון צבעים ===
הכלי מציג את תגובת-התדר של [[wikipedia:he:מעגל RC|מעגל RC]] כפי שנותח ב[[הכרת מכשירי מדידה חלק א#תשובה לתכנון מעגל מסנן מעביר-גבוהים|תשובה לתכנון מעגל מסנן מעביר-גבוהים בדו"ח מכין 1א']], המטרה כאן היא להזיז את סַמָּן הציר-האופקי (ציר <u>הזמן</u> - לא תדר) וסַמָּן הציר-האנכי (ציר המתח) ולנסות לשלוף את תדר-הברך ומתח-הברך בצורה ידנית פעם בציר-לוגריתמי ופעם בציר-ליניארי כדי לפתח את האינטואיציה בקריאת מוצא ה[[מחולל אותות]] המוצג על-גבי מסך ה[[משקף תנודות]].

{| class="wikitable"
|-
! ייצוג
! צבע
! הסבר
|-
| style="text-align:center;" | אות-המקור
| style="text-align:center;background-color:#ff96ff;color:White;" | ורוד
| יוצא מה[[מחולל אותות]], קשה קצת לראות אותו כיוון שהוא מתחבא מאחורי שני גרפים אחרים (בעת לחיצה על כפתור הדוגמא ד'3 למשל הוא יהיה ברור יותר), זהו אות-סינוסואידלי בעל משרעת (אמפליטודה) קבועה בהתאם לערך V<sub>IN</sub> אך תדר משתנה בהתאם לתחום התדרים אשר סומן בכלי (תדר-סיום ותדר-התחלה)
|-
| rowspan="2" style="text-align:center;" | מתח הקבל
| style="text-align:center;background-color:#32ff00;" | ירוק
| האות-הסינוסואידלי המתקבל על מסך ה[[משקף תנודות]] כתוצאה מסריקת-התדרים המתבצעת דרך ה[[מחולל אותות]].
|-
| style="text-align:center;background-color:Blue;color:White;" | כחול
| מסמן את <u>המעטפת</u> של התגובה לתדר שזהו הגרף שאנו רגילים לצייר בשיעור.
|-
| rowspan="2" style="text-align:center;" | מתח הנגד
| style="text-align:center;background-color:Yellow;" | צהוב
| מסמן את האות-הסינוסואידלי המתקבל על מסך ה[[משקף תנודות]] כתוצאה מסריקת-התדרים המתבצעת דרך ה[[מחולל אותות]].
|-
| style="text-align:center;background-color:Red;color:White;" | אדום
| מסמן את <u>המעטפת</u> של התגובה לתדר שזהו הגרף שאנו רגילים לצייר בשיעור.
|-
| style="text-align:center;" | סמנים - Cursors
| style="text-align:center;background-color:#ff8400;color:White;" | כתום
| נועדו לסמן את נקודות העניין, ניתן להזיז אותם באמצעות גרירתם למקום המתאים:
* סַמָּן הציר-האנכי מסמן את ציר-המתח - צריך לדעת כיצד לשלוף את המתח בו נמצא תדר-הברך (הוא תמיד שווה למתח-המירבי חלקי שורש 2).
* סַמָּן הציר-האופקי מסמן את <u>ציר-הזמן בשניות</u> - צריך לדעת איך לשלוף את התדר f ואת התדירות-המעגלית &omega; גם בציר-ליניארי וגם בציר-לוגריתמי.
|}
* <u>הערה</u>: הצטלבות הגרף האדום והגרף הכחול מסמלת את מיקום מתח-הברך ותדר-הברך.

=== דוגמאות ===
{| class="wikitable"
|+ דוגמאות מוכנות מראש
|-
! rowspan="2" | ציר
! rowspan="2" | דוגמא
! colspan="4" | הסבר
|-
! תדר סריקה התחלתי
! תדר סריקה סופי
! זמן סריקה *
! תדר מחולץ בהתאם לזמן (t שווה לסַמָּן X)
|-
| rowspan="2" | לוגריתמי
| ד'1
| 1 הרץ
F<sup>0</sup>
| F הרץ
F<sup>1</sup>
| שנייה אחת
&lrm;0&nbsp;&le;&nbsp;t&nbsp;&le;&nbsp;1
| F בחזקת t הרץ
&lrm;f=F<sup>t</sup>&nbsp;Hz
|-
| ד'2
| 1 הרץ
10<sup>0</sup>
| 10 בחזקת D
10<sup>D</sup>
| D שניות
&lrm;0&nbsp;&le;&nbsp;t&nbsp;&le;&nbsp;D
| 10 בחזקת t הרץ
&lrm;f=10<sup>t</sup>&nbsp;Hz
|-
| rowspan="2" | ליניארי
| ד'3
| 1000 הרץ
1 קילו-הרץ
| 2000 הרץ
2 קילו-הרץ
| שנייה אחת
&lrm;0&nbsp;&le;&nbsp;t&nbsp;&le;&nbsp;1
| התדר ההתחלתי ועוד t במילי-שניות
&lrm;f=1000+1000&middot;t&nbsp;Hz
|-
| ד'4
| 0 הרץ *
| &lrm;1000&middot;D הרץ
D&middot;1kHz
| D שניות
&lrm;0&nbsp;&le;&nbsp;t&nbsp;&le;&nbsp;D
| מיקום t במילי-שניות - באופן ישיר
&lrm;f=1000&middot;t&nbsp;Hz
|}
<u>הערות</u>
* זמן הסריקה הינו הזמן שלוקח ל[[מחולל אותות]] לרוץ על כל התדרים, ככל שהוא ארוך יותר - כך נצטרך לחכות יותר זמן עד שהמסך יסיים להתעדכן ולכן רצוי לדעת לעבוד עם זמנים נמוכים של שנייה אחת או כמה שניות בודדות.
* אין תדר 0 בסריקה של ה[[מחולל אותות]] (אם כי ניתן ליצור DC שהתדר שלו הוא אפס), אך ניתן לקבוע תדר ממש נמוך כמו 1&mu;Hz בתור אפס, זה בסדר כשזה בציר ליניארי, אך בציר לוגריתמי רצוי להתחיל מתדר 1 הרץ כיוון שאם נתחיל ב-1&mu;Hz ונסיים ב-100 הרץ אז 75% מהזמן ה[[מחולל אותות]] יבזבז על התדרים הנמוכים עד 1 הרץ ורק 25% בין 1 הרץ ל-100 הרץ.

=== היישום ===

<jsxgraph height="600" width="600" box="jxg:sweep">
(function(){
 var
  do_round = function(value2round) {return Math.round(value2round*100)/100;},
  // metric prefixes ranges
  ranges = [
    { divider: 1e6 , suffix: '&nbsp;M' },
    { divider: 1e3 , suffix: '&nbsp;k' },
    { divider: 1 , suffix: '&nbsp;' },
    { divider: 1e-3 , suffix: '&nbsp;m' },
    { divider: 1e-6 , suffix: '&nbsp;&mu;' }
  ],
  metric_prefix = function(n) {
    for (var i = 0; i < ranges.length; i++) {
      if (n >= ranges[i].divider) {
        return (do_round(n / ranges[i].divider)).toString() + ranges[i].suffix;
      }
    }
    return n.toString();
  },
  // set size of an input box
  set_size = function(input_box, new_size) {
    window.document.getElementById(input_box.rendNodeTag.id).size = new_size.toString();
    return input_box;
  },
  // set text value of an input box
  set_value = function(input_box, new_value) {
    new_val_str = new_value.toString();
    if (new_value < 0.01) {
      new_val_str = new_value.toExponential();
    }
    window.document.getElementById(input_box.rendNodeTag.id).value = new_val_str;
    return input_box;
  },
  // boundaries of graph
  x_left = -0.5, x_right = 10, y_top = 4, y_bottom = -6,
  new_x_right = x_right,
  // colors
  y = "#ffff00" /* yellow */, g = "#32ff00" /* green */, p = "#ff96ff" /* pink */, o = "#ff8400" /* orange */, r = '#ff0000' /* red */, b = "#0000ff" /* blue */,
  axis_type = ['ליניארי', 'לוגריתמי'],
  brd = JXG.JSXGraph.initBoard('jxg:sweep', {boundingbox: [x_left, y_top, x_right, y_bottom], axis:true, showCopyright:false, showNavigation:false, numberPointsLow: 100, numberPointsHigh: 200}),
  // widgets positions
  x1 = 0.25, x2 = 3.25, y1 = -4, step = 0.5,
  xx1 = 5.25, xx2 = xx1+2.25,
  max_v = 4,
  freeze_points = function(slider) {
    slider.point1.setAttribute({frozen:true});
    slider.point2.setAttribute({frozen:true});
    return slider;
  },
  v_src = freeze_points(brd.create('slider',[[x1,y1-0*step],[x2, y1-0*step],[0.1,2*Math.sqrt(2),max_v]], {name:'V<sub>IN</sub>'})),
  AXIS_LIN = 0, AXIS_LOG = 1, axis = 0, /* log or linear scale */
  btn_log = brd.create('button', [x1, y1-1*step, axis_type[axis], function() {
     axis = (axis+1) % 2;
     this.rendNodeTag.textContent = axis_type[axis];
    }], {fixed: true, frozen: true}),
  example = function(new_axis, new_f_start, new_f_stop, new_cap, new_res, new_sweep) {
      // if scale is log - then change it to linear and vice versa
      if (axis != new_axis) {
        window.document.getElementById(btn_log.rendNodeTag.id).click();
      };
      sld_start.setValue(Math.log10(new_f_start));
      sld_stop.setValue(Math.log10(new_f_stop));
      set_value(txt_cap, new_cap);
      set_value(txt_res, new_res);
      sweep_time.setValue(new_sweep);
      sweep_time_change();
  },
  // example ex4
  btn_ex4 = brd.create('button', [x1+1.5, y1-1*step, "ד'4", function() {
      example(AXIS_LIN, 1e-6, 3000, 0.01, 0.01, 3);
    }], {fixed: true, frozen: true}),
  // example ex3
  btn_ex3 = brd.create('button', [x1+2.3, y1-1*step, "ד'3", function() {
      example(AXIS_LIN, 1000, 2000, 0.01, 0.01, 1);
    }], {fixed: true, frozen: true}),
  // example ex2
  btn_ex2 = brd.create('button', [x1+3.1, y1-1*step, "ד'2", function() {
      example(AXIS_LOG, 1, 1e5, 1e-6, 159, 5);
    }], {fixed: true, frozen: true}),
  // example ex1
  btn_ex1 = brd.create('button', [x1+3.9, y1-1*step, "ד'1", function() {
      example(AXIS_LOG, 1, 1e5, 1e-6, 159, 1);
    }], {fixed: true, frozen: true}),
  sld_start = freeze_points(brd.create('slider',[[xx1,y1-0*step],[xx2, y1-0*step],[-6,0,7]], {withLabel: false})),
  lbl_start = brd.create('text', [xx2+0.1,y1-0*step,function() {return 'תדר התחלה=<span dir="ltr">' + metric_prefix(Math.pow(10, sld_start.Value())) + 'Hz</span>';}], {fixed: true, frozen: true}),
  sld_stop = freeze_points(brd.create('slider',[[xx1,y1-1*step],[xx2, y1-1*step],[-6,2,7]], {withLabel: false})),
  lbl_stop = brd.create('text', [xx2+0.1,y1-1*step,function() {return 'תדר סיום=<span dir="ltr">' + metric_prefix(Math.pow(10, sld_stop.Value())) + 'Hz</span>';}], {fixed: true, frozen: true}),
  sweep_time = freeze_points(brd.create('slider',[[xx1,y1-2*step],[xx2, y1-2*step],[1,10,16]], {name:'זמן סריקה', snapWidth: 1})),
  txt_cap = set_size(brd.create('input', [xx1, y1-3*step, '0.159', 'קבל='], {fixed: true, frozen: true}), 7),
  txt_res = set_size(brd.create('input', [xx2, y1-3*step, '0.1', 'נגד='], {fixed: true, frozen: true}), 7),
  calc_cutoff = function() {return 1/(2*Math.PI*txt_cap.Value()*txt_res.Value());},
  f_cutoff = function() {return 'f<sub>cutoff</sub>=1/2&pi;RC=' + do_round(calc_cutoff())+'&nbsp;Hz'},
  v_cutoff = function() {return 'V<sub>cutoff</sub>=' + do_round(v_src.Value()) + '/&radic;2=' + do_round(v_src.Value()/Math.sqrt(2))+'&nbsp;V'},
  lbl_cutoff = brd.create('text', [x1,y1-2*step,function() {return f_cutoff() + '; ' + v_cutoff();}], {fixed: true, frozen: true}),

  // horizontal cursor line
  p_hcur1 = brd.create('point', [x_left, max_v-1], {visible:false}),
  p_hcur2 = brd.create('point', [x_right, max_v-1], {visible:false}),
  h_cursor = brd.create('line', [p_hcur1, p_hcur2], {strokeColor: o, strokeWidth: 3}),

  // vertical cursor line
  x_center = Math.floor((x_right - x_left) / 2),
  p_vcur1 = brd.create('point', [x_center, max_v-0.5], {visible:false}),
  p_vcur2 = brd.create('point', [x_center, -(max_v-0.5)], {visible:false}),
  v_cursor = brd.create('line', [p_vcur1, p_vcur2], {strokeColor: o, strokeWidth: 3}),

  // low frequency according to position to improve performance
  freq_of_t_low = function(t) {
    var dx = 1.0*new_x_right;
    var freq_log = Math.max(sld_start.Value(), sld_stop.Value());
    if (freq_log < 1) {
      freq_log = 1;
    }
    freq_log = Math.log10(freq_log);
    return (t/dx/dx)*Math.pow(10, 1.0 + freq_log);
  },
  // frequency according to position
  freq_of_t = function(t) {
    var f1 = Math.pow(10, sld_start.Value()), f2 = Math.pow(10, sld_stop.Value()), dx = sweep_time.Value();
    if (axis == 0) {
      // linear scale
      return (Math.abs(f2-f1)*t/dx + 1.0*Math.min(f1,f2));
    } else {
      // logarithmic scale
      if (f1 == 0) {
        f1 = 1;
      }
      f1 = Math.log10(f1);
      f2 = Math.log10(f2);
      var freq_power = (Math.abs(f2-f1)*t/dx + 1.0*Math.min(f1,f2));
      return Math.pow(10, freq_power);
    }
  },
  // track cursors
  h_cursor_pos = function() {return 'Y=' + do_round(p_hcur1.Y()) + ' V';},
  v_cursor_pos = function() {return 'X=' + p_vcur1.X().toFixed(3) + ' s (<b><font color="Red">*' + do_round(freq_of_t(p_vcur1.X())) + ' Hz</font></b>)';},
  lbl_cursors = brd.create('text', [x1,y1-3*step,function() {return 'Cursors: ' + v_cursor_pos() + '; ' + h_cursor_pos();}], {fixed: true, frozen: true}),
  // draw graphs
  wrc_of_f = function(freq) { /* Omega * R * C */
    return 2*Math.PI*freq*txt_cap.Value()*txt_res.Value();
  },
  faster = function(t, value) {return t>=0? value : 0},
  // Sine wave for Source
  f_src = brd.create('functiongraph',[function(t){
    var freq = freq_of_t_low(t);
    return faster(t, v_src.Value()*Math.sin(2*Math.PI*freq*t));
  }], {strokeColor: p, highlight: false}),
  // resistor frequency value
  f_res = brd.create('functiongraph',[function(t){
    var wrc = wrc_of_f(freq_of_t(t));
    var v_res = v_src.Value() * wrc / Math.sqrt(wrc*wrc+1);
    return faster(t, v_res*Math.sin(2*Math.PI*freq_of_t_low(t)*t));
  }], {strokeColor: y, highlight: false}),
  // capacitor frequency value
  f_cap = brd.create('functiongraph',[function(t){
    var wrc = wrc_of_f(freq_of_t(t));
    var v_cap = v_src.Value()  / Math.sqrt(wrc*wrc+1);
    return faster(t, v_cap*Math.sin(2*Math.PI*freq_of_t_low(t)*t));
  }], {strokeColor: g, highlight: false}),
  // resistor voltage value
  v_res = brd.create('functiongraph',[function(t){
    var wrc = wrc_of_f(freq_of_t(t));
    return faster(t, v_src.Value() * wrc / Math.sqrt(wrc*wrc+1));
  }], {strokeColor: r, strokeWidth: 2}),
  // capacitor voltage value
  v_cap = brd.create('functiongraph',[function(t){
    var wrc = wrc_of_f(freq_of_t(t));
    return faster(t, v_src.Value()  / Math.sqrt(wrc*wrc+1));
  }], {strokeColor: b, strokeWidth: 2}),
  sweep_time_change = function() {
    new_x_right = sweep_time.Value();
    brd.setBoundingBox([x_left/10*new_x_right, y_top, new_x_right, y_bottom]);
    if (p_vcur1.X() >= new_x_right)
    {
      p_vcur1.moveTo([new_x_right*0.95, p_vcur1.Y()]);
      p_vcur2.moveTo([new_x_right*0.95, p_vcur2.Y()]);
    }
  };

  sweep_time.on('up', function(){
    sweep_time_change();
  });

  })();
</jsxgraph>

* <u>הערה</u>: בכלי לעיל רשום ליד סַמָּן ציר X בסוגריים ב'''<font color="Red">צבע-אדום</font>''' את התדר המחושב, אך במציאות אנו לא נקבל אותו בצורה אוטומטית כיוון שה[[משקף תנודות]] אינו יודע את מאפייני סריקת-התדרים, וזוהי המטרה של כלי זה - לעזור לנו להבין כיצד לחשב בעצמנו את התדר בהתאם למאפיינים הבאים:
*# המיקום בשניות של סַמָּן X.
*# משך זמן סריקת-התדרים - בשניות.
*# תחום סריקת-התדרים - התדר-ההתחלתי והתדר הסופי.
*# סוג ציר סריקת-התדרים - לוגריתמי או ליניארי.

=== חישובים תיאורטיים ===
==== סריקה ליניארית ====

<math>f=(f_T-f_0)\cdot\frac{t_C}{T}+f_0</math>

ניתן לפשט את הנוסחא אם:
* זמן הסריקה T הוא שנייה אחת, כלומר T=1
*תדר ההתחלה הוא 0 הרץ, כלומר f<sub>0</sub>=0

אז מקבלים:

<math>f=(f_T-0)\cdot\frac{t_C}{1}+0=f_T\cdot t_C</math>

כלומר מכפלת התדר-הסופי והמיקום בשניות היא התדר המסומן.

==== סריקה לוגריתמית ====

<math>f=10^{\Big(\big(log(f_T)-log(f_0)\big)\cdot\frac{t_C}{T}+log(f_0)\Big)}=10^{\Big(\big(log\frac{f_T}{f_0}\big)\cdot\frac{t_C}{T}+log(f_0)\Big)}</math>

ניתן לפשט את הנוסחא אם:
* זמן הסריקה T הוא שנייה אחת, כלומר T=1
* תדר ההתחלה הוא 1 הרץ (ולא 0 הרץ כמו בסריקה הליניארית), כלומר f<sub>0</sub>=1

אז מקבלים:

<math>f=10^{\Big(\big(log\frac{f_T}{1}\big)\cdot\frac{t_C}{1}+log(1)\Big)}=10^{log(f_T)\cdot t_C}=f_T^{t_C}</math>

כלומר מקבלים שהתדר-הסופי בחזקת המיקום בשניות הוא התדר המסומן.

<br clear="all"/>

= מגבלות =
[[File:MeasureOutputResistance.svg|thumb|left|300px|<figure id="fig:rsetup"><caption>מערך מדידה להמחשת השפעת ההתנגדות הפנימית</caption> Rs=50Ω של ה'''מחולל''' על העומס (נוצר באמצעות [http://www.digikey.com/schemeit/ Scheme-It])</figure>]]
# התנגדות המוצא היא Rs=50Ω (כפי שמוטבע על המכשיר ב<xr id="fig:awg"/> מצד שמאל למוצא), ניתן לכוון את התנגדות העומס R_LOAD לערכים של בין 1Ω ל-10kΩ או אינסוף, אך עדיין זה לא ישנה את ההתנגדות הפנימית Rs של ה'''מחולל''' שהיא קבועה על 50Ω אלא זה רק ישנה את צורת פיצוי המתח של ה'''מחולל'''.
# כיוון שיש התנגדות פנימית של 50Ω ל'''מחולל''' - הוא לא יכול לשמש בתור ספק-מתח עבור עומס נמוך כיוון שמחלק המתח יגרום לכך שפחות מדי מתח ייפול על העומס, אם לדוגמא העומס הוא נגד של R_LOAD=5Ω כפי שרואים ב<xr id="fig:rsetup"/> ונוציא מתח של 10V מה'''מחולל''', הנגד יקבל רק V<sub>R</sub>=10V&middot;5&Omega;/(5&Omega;+50&Omega;)=0.91V
<br clear="all"/>

= הערות =
* דגם זה כולל בתוכו שני מכשירים:
*# [[wikipedia:he:מחולל אותות|'''מחולל אותות''']] (בלועזית [[wikipedia:Function generator|'''Function Generator''']]) המייצר אותות בסיסיים בלחיצת כפתור כגון סינוס, מרובע, שן-משור (רמפה).
*# '''מחולל צורת-גל שרירותית''' (בלועזית [[wikipedia:Arbitrary waveform generator|AWG - Arbitrary Waveform Generator]]) המאפשר ליצור כל צורת אות לבחירתנו בשיטת [[wikipedia:Direct digital synthesizer|סינתוז ספרתי ישיר]] ע"י איור הגל בעזרת תוכנת מחשב, או ע"י לחיצה על כפתור ARB ותכנות ידני, ניתן ליצור גרף עם עד 64K נקודות בדגם זה אשר יסונתז בצורה מחזורית (פרק 7 ב[{{manuals}}/Agilent%2033220A.pdf#page=313 מדריך למשתמש]).