הצעה לפתרון מלא — אלקטרוניקה ומחשבים
בגרות · קיץ תשע"ט 2019 · שאלון 815381 · שאלות 1–22
✦ בנוי על ידי פהד גאנם ✦
💡
על המסמך: הצעה לפתרון מלא לשאלון 815381 — אלקטרוניקה ומחשבים, קיץ תשע"ט 2019. השאלון בנוי משני חלקים: חלק א' (שאלות 1–8, לתוכנית הלימודים החדשה) ובו פרק ראשון (תורת החשמל), פרק שני (אלקטרוניקה תקבילית וספרתית) ופרק שלישי (תכנות ב-C#); חלק ב' (שאלות 9–22, לתוכנית הלימודים הישנה) ובו פרק רביעי (מבוא לאלקטרוניקה), פרק חמישי (תורת החשמל) ופרק שישי (מבוא להנדסת מחשבים — תכנות ב-C ו-Arduino). כמה שאלות בחלק ב' זהות לשאלות בחלק א' — צוין בכל מקום. כאן פתורות כל השאלות, לנוחות הלימוד.
🔌 חלק א' · פרק ראשון — יסודות תורת החשמל (שאלות 1–2)
שאלה 1 — מעגל נגדים עם מד-מתח
נתונים: R₁ = 2 kΩ · R₂ = 3.3 kΩ · R₃ = 4.7 kΩ · R₄ = 10 kΩ · קריאת מד-המתח (על R₃) = 9.4V
💡
מבנה המעגל: R₁ בטור מהמקור אל הצומת העליון T. מ-T יורדים שני ענפים מקבילים בין T לפס התחתון: הענף (R₂ בטור עם R₃) והנגד R₄. מד-המתח מחובר על R₃ (בין צומת האמצע לפס התחתון) וקורא 9.4V. מד-מתח אידיאלי אינו מושך זרם.
סעיף א — הזרם דרך R₄

הזרם בענף R₂–R₃ נובע ישירות ממתח R₃. ממנו מקבלים את המתח על R₂ ואת מתח T אל הפס התחתון, שהוא גם המתח על R₄:

I(R₂,R₃) = U(R₃)R₃ = 9.44700 = 2 mA
U(R₂) = 2m × 3300 = 6.6 V → UT = U(R₂) + U(R₃) = 6.6 + 9.4 = 16 V
I(R₄) = UTR₄ = 1610000
I(R₄) = 1.6 mA
סעיף ב — המתח על R₁

הזרם דרך R₁ הוא הזרם הכולל של המקור — סכום הזרמים בשני הענפים המקבילים:

Itot = I(R₂,R₃) + I(R₄) = 2 + 1.6 = 3.6 mA
U(R₁) = Itot · R₁ = 3.6m × 2000
U(R₁) = 7.2 V
סעיף ג — מתח המקור E
E = U(R₁) + UT = 7.2 + 16
E = 23.2 V
סעיף ד — ההספק על R₂
P(R₂) = I(R₂,R₃)² · R₂ = (2m)² × 3300
P(R₂) = 13.2 mW
שאלה 2 — מעגל RC טורי בזרם חילופין
נתונים: R = 1.2 kΩ · קריאת מד-המתח (על R) = 6V (יעיל) · משקף תנודות על C: Vp-p = 22.63V · 5 msec/div
סעיף א — הזרם היעיל במעגל

בחיבור טורי הזרם משותף לנגד ולקבל, ונחשב אותו ממתח הנגד הנתון:

I = URR = 61200
I = 5 mA
סעיף ב — תדר מקור-המתח (מהמסך)

במסך משקף התנודות המרחק בין שתי פסגות סמוכות הוא 4 משבצות, וכל משבצת = 5 msec. מכאן זמן המחזור והתדר:

T = 4 div × 5 msec = 20 msec
f = 1T = 10.02
f = 50 Hz
סעיף ג — ערכו של הקבל C

מהמסך קוראים את מתח הקבל: המשרעת היא חצי מ-Vp-p, והערך היעיל קטן ממנה פי √2. מתוכו מקבלים את היגב הקבל XC ואת הקיבול:

UC(yaʿil) = Vp-p2√2 = 22.632.828 = 8 V
XC = UCI = 80.005 = 1600 Ω
C = 12π f XC = 12π × 50 × 1600
XC = 1.6 kΩ ; C ≈ 1.99 µF ≈ 2 µF
סעיף ד — המתח היעיל של מקור-המתח

בחיבור טורי RC המתחים מצטרפים וקטורית (הפרש פאזה 90°), ולכן:

Vs = √UR² + UC² = √6² + 8² = √100
Vs = 10 V
⚙️ פרק שני — אלקטרוניקה תקבילית וספרתית (שאלות 3–5)
שאלה 3 — מגבר טרנזיסטור במוצא משותף (CE)
נתונים: hie=1.5kΩ · hfe=β=50 · VBE=0.7V · VCE=6V · VCC=12V · RL=2kΩ · קריאת מד-הזרם (באמיטר) = 2mA
⚠️
הנחה: מד-הזרם מודד את זרם האמיטר. מכיוון ש-β גדול נהוג לקרב IC ≈ IE = 2mA. האמיטר מוארק (ללא RE), והמעגל בהזנה קבועה (RB מ-VCC לבסיס, RC מ-VCC לקולקטור).
סעיף א — זרם הקולקטור IC
IC ≈ IE = 2 mA
IC ≈ 2 mA
סעיף ב — הנגדים RB ו-RC

RC נקבע ממשוואת המוצא (ללא RE), ו-RB ממשוואת הבסיס עם זרם הבסיס IB=IC/β:

RC = VCC - VCEIC = 12 - 60.002 = 3 kΩ
IB = ICβ = 2m50 = 40 µA
RB = VCC - VBEIB = 12 - 0.740µ
RC = 3 kΩ ; RB = 282.5 kΩ
סעיף ג — דגם חילופין זעיר

בזרם חילופין הקבלים C₁, C₂ מהווים קצר. מתח המבוא Vi מגיע דרך C₁ אל הבסיס; המעבר בסיס-אמיטר מיוצג בהתנגדות hie=1.5kΩ; במוצא פועל מקור זרם תלוי β·ib בקולקטור; העומס לחילופין הוא RC ∥ RL; ו-RB מחובר בין הבסיס לאדמת החילופין.

סעיף ד — הגבר המתח AV
RC ∥ RL = 3000 × 20003000 + 2000 = 1200 Ω
AV = - β (RC ∥ RL)hie = - 50 × 12001500
AV = -40 (מהפך, |AV| = 40)
שאלה 4 — מגבר הפרש עם מגבר שרת
נתונים: R₃=5kΩ (V₂ → כניסה −) · R₄=10kΩ (משוב) · R₁=10kΩ (V₁ → כניסה +) · R₂=10kΩ (כניסה + לאדמה) · הזנה ±12V
סעיף א — ביטוי מתח המוצא Vo

הכניסה החיובית מקבלת חלוקת מתח: V₊ = V₁·R₂/(R₁+R₂) = V₁/2. במגבר אידיאלי V₋ = V₊. כותבים חוק זרמים בצומת הכניסה השלילית:

V₂ - V₋R₃ = V₋ - VoR₄ → 2(V₂ - V₋) = V₋ - Vo
Vo = 3V₋ - 2V₂ = 3·V₁2 - 2V₂
Vo = 1.5·V₁ - 2·V₂
סעיף ב — Vo עבור V₁=2V , V₂=0V
Vo = 1.5×2 - 2×0 = 3 V
Vo = 3 V
סעיף ג — V₂=1V , V₁=2·sin(100πt) V

1) הצבה בביטוי המוצא:

Vo(t) = 1.5·(2 sin(100πt)) - 2·1 = 3 sin(100πt) - 2 [V]

2) גרף Vo(t): גל סינוס במשרעת 3V סביב מתח מוצא (DC) של ‎−2V — כלומר מתנדנד בין ‎+1V (שיא) ל-‎−5V (שפל), בתדר f = 100π/2π = 50 Hz (זמן מחזור 20 msec). שני הקצוות בתחום ±12V, ולכן אין רוויה ואין גזירת הגל.

Vo(t) = 3 sin(100πt) - 2 V ; בין +1V ל-−5V ; T = 20 msec
שאלה 5 — נגד רגיש לאור (LDR) עם שני משווים ו-LED
נתונים: אספקה 6V · R₁=20kΩ (עם LDR מחלק את C) · שלושה נגדי 5kΩ בטור (מחלק A,B) · R₂=1kΩ בטור עם LED
💡
מבנה המעגל: C הוא צומת מחלק LDR–R₁. שלושה נגדי 5kΩ בטור מ-6V לאדמה יוצרים את הצמתים A (עליון) ו-B (תחתון). המשווה העליון: כניסה + מחוברת ל-C וכניסה − ל-A. המשווה התחתון: כניסה − מחוברת ל-C וכניסה + ל-B. ה-LED (בטור עם R₂) מחובר בין Vo1 ל-Vo2 ונדלק רק כאשר Vo1 גבוה ו-Vo2 נמוך.
סעיף א — המתח בנקודות A ו-B
VA = 6 · 5k + 5k15k = 4 V
VB = 6 · 5k15k = 2 V
VA = 4 V ; VB = 2 V
סעיף ב — תחום VC שבו ה-LED דולק

Vo1 גבוה (6V) כאשר VC > VA = 4V. Vo2 נמוך (0V) כאשר VC > VB = 2V. ה-LED דולק כאשר Vo1 גבוה וגם Vo2 נמוך — כלומר כאשר VC גדול מ-4V:

4 V < VC < 6 V (ה-LED דולק)
סעיף ג — אופייני המעבר Vo1=f(VC) ו-Vo2=f(VC)

Vo1: ‎0V כל עוד VC < 4V, וקופץ ל-‎6V כאשר VC > 4V.
Vo2: ‎6V כל עוד VC < 2V, ויורד ל-‎0V כאשר VC > 2V.

תחום VCVo1Vo2LED
VC < 2V0V6Vכבוי
2V < VC < 4V0V0Vכבוי
VC > 4V6V0Vדולק
סעיף ד — תחום עוצמת ההארה (lux) שבו ה-LED דולק

התנאי VC > 4V שקול, דרך מחלק המתח VC = 6·20/(RLDR+20), לתנאי על התנגדות ה-LDR:

6 · 20RLDR + 20 > 4 → RLDR < 10 kΩ

מהגרף (התנגדות ה-LDR מול עוצמת ההארה), התנגדות של 10kΩ מתקבלת בעוצמת הארה של כ-‎11 lux. ה-LDR קטן מ-10kΩ בהארות חזקות יותר, ולכן ה-LED דולק בעוצמת הארה גדולה מכ-‎11 lux (בערך התחום ‎11–20 lux בגרף).

ה-LED דולק כאשר RLDR < 10 kΩ ⟵ הארה ≳ 11 lux
💻 פרק שלישי — תכנות בשפת C# (שאלות 6–8)
שאלה 6 (C#) — המחלקה ArithmeticSeries
המחלקה: סדרה חשבונית עם איבר ראשון a1 והפרש d · הפעולה An(n) מחזירה את האיבר ה-n: a1 + (n-1)·d
סעיף א — הפלט של קטע הקוד

‎seq1 נוצר עם a1=3, d=2, ולכן An(1)=3, An(2)=5, An(3)=7. הלולאה מדפיסה אותם וסוכמת אותם ל-sum3=15. אחר כך seq2 נוצר עם a1=15 ו-d=seq1.GetD()=2, ו-An(2)=15+2=17:

seq1 = ArithmeticSeries(3, 2) An(1)=3 , An(2)=5 , An(3)=7 → sum3 = 3+5+7 = 15 seq2 = ArithmeticSeries(15, 2) An(2) = 15 + (2-1)*2 = 17
3 5 7 sum3=15 17
סעיף ב — ערכי התכונות בסיום ההרצה
עצםa1d
seq132
seq2152
סעיף ג — קטע קוד: סדרה חשבונית a1=10, d=5, איברים 7 עד 100
ArithmeticSeries seq = new ArithmeticSeries(10, 5); for (int i = 7; i <= 100; i++) Console.WriteLine(seq.An(i));
סעיף ד — האם ניתן לשנות את d לאחר יצירת העצם?

לא ניתן. במחלקה קיימת רק פעולת SetA1 לשינוי a1, אך אין פעולת SetD, והתכונה d מוגדרת private. לכן לאחר יצירת העצם אין דרך לשנות את הפרש הסדרה מבחוץ. כדי לאפשר זאת היה צורך להוסיף למחלקה פעולה מסוג:

public void SetD(int d) { this.d = d; }
שאלה 7 (C#) — מכירת שוברים בירידׁ התרמה
נתונים: שובר בודד = 6 ש"ח · שובר כפול = 10 ש"ח · רכישה מעל 50 ש"ח מזכה בשובר כפול חינם

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

int single, dbl; double total = 0; int freeDoubles = 0; Console.Write("Enter single vouchers: "); single = int.Parse(Console.ReadLine()); Console.Write("Enter double vouchers: "); dbl = int.Parse(Console.ReadLine()); while (single != -1 && dbl != -1) { double pay = single * 6 + dbl * 10; Console.WriteLine("Amount to pay: " + pay); if (pay > 50) { Console.WriteLine("You get a free double voucher!"); freeDoubles++; } total = total + pay; Console.Write("Enter single vouchers: "); single = int.Parse(Console.ReadLine()); Console.Write("Enter double vouchers: "); dbl = int.Parse(Console.ReadLine()); } Console.WriteLine("Total collected: " + total); Console.WriteLine("Free double vouchers: " + freeDoubles);
שאלה 8 (C#) — פלינדרום ארבע-ספרתי (IsPalindrome4)
נתון: הפעולה IsPalindrome4(num) מחזירה true אם המספר הוא פלינדרום בן ארבע ספרות בדיוק
סעיף א — הפלט של קטע הקוד

הלולאה רצה עד שנספרו שלושה פלינדרומים (b=3). נבדוק כל קלט (קריאה משמאל לימין): b סופר פלינדרומים, c סופר את השאר:

9119 → פלינדרום 4 ספרות ✓ b=1 1111 → פלינדרום 4 ספרות ✓ b=2 24 → לא 4 ספרות ✗ c=1 575 → לא 4 ספרות ✗ c=2 1331 → פלינדרום 4 ספרות ✓ b=3 → הלולאה נעצרת סה"כ קלטים = b + c = 3 + 2 = 5
Total number of inputs:5 Total 4 digit palindrome inputs:3
סעיף ב — דוגמת קלט שבסופה c = 0

כדי ש-c יישאר 0, כל הקלטים עד עצירת הלולאה חייבים להיות פלינדרומים ארבע-ספרתיים. שלושה כאלה מספיקים:

1221 , 3443 , 8558 // c נשאר 0, b מגיע ל-3 והתוכנית מסתיימת
סעיף ג — האם קיימת סדרת קלט שבסופה b = 1?

לא. הלולאה while (b!=3) מסתיימת אך ורק כאשר b מגיע ל-3. אם ייקלט רק פלינדרום אחד (b=1), b לעולם לא יגיע ל-3 והלולאה תרוץ ללא הפסקה (לולאה אינסופית) — ולכן התוכנית לא יכולה להסתיים עם הערך b=1.

סעיף ד — סכום הלא-פלינדרומים וכמות הפלינדרומים במערך
int sum = 0, count = 0; for (int i = 0; i < arr.Length; i++) { if (IsPalindrome4(arr[i])) count++; // סופר פלינדרומים 4-ספרתיים else sum = sum + arr[i]; // סוכם את יתר המספרים } Console.WriteLine("Sum of non-palindromes: " + sum); Console.WriteLine("Count of 4-digit palindromes: " + count);
📐 חלק ב' · פרק רביעי — מבוא לאלקטרוניקה (שאלות 9–12)
שאלה 9 — מגבר טרנזיסטור CE (זהה לשאלה 3)
שים לב: שאלה זו זהה במלואה לשאלה 3 — אותו מעגל ואותם נתונים. הפתרון המלא מופיע בשאלה 3.
IC ≈ 2 mA ; RC = 3 kΩ ; RB = 282.5 kΩ ; AV = -40
שאלה 10 — מגבר הפרש עם מגבר שרת (זהה לשאלה 4)
שים לב: שאלה זו זהה במלואה לשאלה 4 — אותו מעגל ואותם נתונים. הפתרון המלא מופיע בשאלה 4.
Vo = 1.5·V₁ - 2·V₂ ; Vo(V₁=2,V₂=0) = 3V ; Vo(t) = 3 sin(100πt) - 2 V
שאלה 11 — ממיר אנלוגי-ספרתי (A/D) בן שמונה סיביות
נתונים: ממיר A/D של 8 סיביות · מהגרף: מדרגות בקצוות 0.01, 0.03, 0.05V ← ערכים 1,2,3 · 5.05→253, 5.07→254, 5.09→255
סעיף א — כושר ההבחנה (הרזולוציה)

כושר ההבחנה הוא שינוי המתח במבוא שגורם לשינוי של סיבית אחת (מדרגה) במוצא. רוחב כל מדרגה בגרף הוא 0.02V:

Resolution = 0.03 - 0.01 = 0.02 V = 20 mV
FS = 2⁸ × 0.02 = 256 × 0.02 = 5.12 V (בדיקה)
כושר ההבחנה = 20 mV (0.02 V)
סעיף ב — הערך הבינארי במוצא

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

Vin = 2 V → N = 20.02 = 100 = 01100100₂
Vin = 3.045 V → N = 3.0450.02 ≈ 152 = 10011000₂
Vin=2V → 01100100 ; Vin=3.045V → 10011000
סעיף ג — תחום מתח-המבוא עבור הערך 01100001₂

‎01100001₂ = 97 בעשרוני. הערך 97 מתאים למדרגה שמרכזה 97×0.02 = 1.94V, וברוחב מדרגה של 0.02V:

01100001₂ = 97 → Vin ≈ 97 × 0.02 = 1.94 V
1.93 V ≤ Vin < 1.95 V
1.93 V ≤ Vin < 1.95 V (מרכז 1.94V)
שאלה 12 — נגד רגיש לאור (LDR) עם משווים (זהה לשאלה 5)
שים לב: שאלה זו זהה במלואה לשאלה 5 — אותו מעגל, אותו גרף ואותם נתונים. הפתרון המלא מופיע בשאלה 5.
VA = 4V ; VB = 2V ; LED דולק ⟺ VC > 4V ⟺ RLDR < 10kΩ (הארה ≳ 11 lux)
🔋 פרק חמישי — תורת החשמל (שאלות 13–14)
שאלה 13 — מעגל נגדים עם מד-מתח (זהה לשאלה 1)
שים לב: שאלה זו זהה במלואה לשאלה 1 — אותו מעגל ואותם נתונים. הפתרון המלא מופיע בשאלה 1.
I(R₄) = 1.6 mA ; U(R₁) = 7.2 V ; E = 23.2 V ; P(R₂) = 13.2 mW
שאלה 14 — מעגל RC טורי בזרם חילופין (זהה לשאלה 2)
שים לב: שאלה זו זהה במלואה לשאלה 2 — אותו מעגל ואותם נתונים. הפתרון המלא מופיע בשאלה 2.
I = 5 mA ; f = 50 Hz ; C ≈ 2 µF (XC=1.6kΩ) ; Vs = 10 V
🖥️ פרק שישי — מבוא להנדסת מחשבים · תכנות ב-C ו-Arduino (שאלות 15–22)
שאלה 15 (C) — קריאת מפסקים והצגה ב-7-seg
נתונים: מפתח-קלט 300H (8 מפסקים S₀–S₇) · מפתח-פלט 301H (תצוגת 7-seg בחיבור קתודה משותפת CC)
💡
בחיבור המפסקים: מפסק סגור ← ‎+5V ← סיבית '1'; מפסק פתוח ← דרך R לאדמה ← סיבית '0'. לכן ספירת המפסקים הפתוחים היא ספירת אפסים. קודי ה-7-seg (CC) לספרות 0–9 הם: 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f.
unsigned char seg[] = {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; void main(void) { unsigned char sw; int i, count; while (1) { sw = in32(0x300); // 1. קליטת מצב המפסקים count = 0; for (i = 0; i < 8; i++) // 2. ספירת המפסקים הפתוחים (סיביות '0') if ((sw & (1 << i)) == 0) count++; if (count == 8) // 4. כל המפסקים פתוחים – הבהוב "8" שלוש פעמים { for (i = 0; i < 3; i++) { out32(0x301, seg[8]); // "8" דולקת delay(1000); // שנייה אחת out32(0x301, 0x00); // כבויה delay(1000); // שנייה אחת } } else out32(0x301, seg[count]); // 3. הצגת מספר המפסקים הפתוחים } }
שאלה 16 (C) — עיבוד מערך ציונים
נתונים: מערך arr בן 35 ציונים בטווח 0–100

שלוש הפעולות — ממוצע, ספירת ציונים מעל 55, והציון הגבוה ביותר — מבוצעות במעברים על המערך:

int i, sum = 0, count = 0, max; double avg; // 1. ממוצע הציונים for (i = 0; i < 35; i++) sum = sum + arr[i]; avg = sum / 35.0; printf("Average = %.2f\n", avg); // 2. מספר הנבחנים שקיבלו ציון הגבוה מ-55 for (i = 0; i < 35; i++) if (arr[i] > 55) count++; printf("Above 55 = %d\n", count); // 3. הציון הגבוה ביותר max = arr[0]; for (i = 1; i < 35; i++) if (arr[i] > max) max = arr[i]; printf("Max = %d\n", max);
שאלה 17 (C) — ניתוח קוד וספירת סיביות
נתונים: מפתח-פלט 301H (7-seg בחיבור CC) · arr1[] = קודי ספרות 0–9 · arr2[] = 9 ערכי בייט
⚠️
הערת דפוס: בלולאה שבשורה 6 מופיעים פסיקים במקום נקודה-פסיק, והתנאי הוא i<10 אף שב-arr2 יש 9 איברים (אינדקסים 0–8). הכוונה היא for(i=0; i<9; i++) — מעבר על תשעת האיברים. כך פתרנו.
סעיף א — הסבר השורות 8, 9, 10, 12
שורההפעולה
8x = arr2[i] & 0x01 — בידוד הסיבית הנמוכה (LSB, bit0) של האיבר
9y = (arr2[i] & 0x80) >> 7 — בידוד הסיבית הגבוהה (MSB, bit7) והזזתה למקום 0 (0 או 1)
10if (x==y) t++ — אם MSB שווה ל-LSB, מגדיל את המונה t
12out32(0x301, arr1[t]) — שולח לתצוגה את קוד ה-7-seg של הספרה t
סעיף ב — הערך שיופיע בתצוגה בסיום

t סופר כמה מאיברי arr2 מקיימים bit0 = bit7. נבדוק את תשעת האיברים:

0xAA=10101010 bit0=0 bit7=1 ✗ 0x80=10000000 bit0=0 bit7=1 ✗ 0x81=10000001 bit0=1 bit7=1 ✓ 0xBB=10111011 bit0=1 bit7=1 ✓ 0xFF=11111111 bit0=1 bit7=1 ✓ 0xA5=10100101 bit0=1 bit7=1 ✓ 0x99=10011001 bit0=1 bit7=1 ✓ 0x7E=01111110 bit0=0 bit7=0 ✓ 0x91=10010001 bit0=1 bit7=1 ✓ t = 7

‎t=7, ולכן out32 שולח את arr1[7]=0x07 — נדלקות המקטעים a,b,c ומופיעה הספרה 7.

בתצוגה מופיעה הספרה 7 (t = 7)
סעיף ג — ערכי arr2 חדשים כך שתופיע הספרה 9

כדי שתופיע הספרה 9 דרוש t=9, כלומר כל תשעת האיברים חייבים לקיים bit0 = bit7. שני האיברים שאינם מקיימים זאת הם 0xAA ו-0x80 — נחליף אותם בערכים שבהם הסיביות הקיצוניות שוות (למשל ‎bit7=bit0=1 או ‎=0):

arr2[] = {0xAB, 0x00, 0x81, 0xBB, 0xFF, 0xA5, 0x99, 0x7E, 0x91}; // ↑ ↑ // 0xAB: bit0=1,bit7=1 ✓ 0x00: bit0=0,bit7=0 ✓ → t = 9 → arr1[9]=0x6f → "9"
סעיף ד — מעבר לתצוגה בחיבור אנודה משותפת (CA)

בחיבור CA מקטע נדלק כאשר הפלט '0' (פעיל-נמוך) — היפוך של CC. לכן משלימים את קוד הפלט (משאירים את הפלט זהה חזותית). משנים את שורה 12:

12. out32(0x301, ~arr1[t]); // השלמה סיבית-סיבית עבור CA
שאלה 18 (C) — מציאת ערך מרבי בקלט
התוכנית: קולטת מספרים שלמים עד שנקלט מספר שאינו חיובי, ומחזיקה ב-x את הערך הגדול ביותר
סעיף א — הסבר השורות 4, 5, 7, 8
שורההפעולה
4x = i — אתחול x בערך הקלט הראשון (x יחזיק את המרבי)
5while(i > 0) — הלולאה נמשכת כל עוד הקלט חיובי; נעצרת בקלט אפס או שלילי
7if (i > x) x = i — עדכון המרבי אם הקלט הנוכחי גדול מ-x
8printf("Enter int number: ") — הצגת הודעת בקשה לקליטת המספר הבא
סעיף ב — הפלט עבור הקלט הנתון

קלט (קריאה משמאל לימין): 4, 5, 6, 3, 4, 5, ‎−1, 8, 1, 0. הלולאה נעצרת ב-‎−1, ולכן הערכים 8, 1, 0 אינם נקלטים כלל:

i=4 → x=4 5 > 4 → x=5 6 > 5 → x=6 3 > 6 → לא 4 > 6 → לא 5 > 6 → לא i=-1 → הלולאה נעצרת (8,1,0 לא נקראו)
x = 6
סעיף ג — שינוי התנאי בשורה 7 ל-if (i < x)

כן — הפלט משתנה. כעת התוכנית מחזיקה בערך המזערי מבין המספרים החיוביים במקום המרבי. עבור אותו קלט: x=4, ואז 3<4 ← x=3 (ושאר הערכים אינם קטנים ממנו):

x = 3
שאלה 19 (Arduino / C) — LM35 ותצוגת 7-seg (CA)
נתונים: חיישן LM35 על A₀ (‎10mV לכל °C) · תצוגת 7-seg בחיבור אנודה משותפת (CA) על D₀–D₆

‎analogRead מחזיר 0–1023 עבור 0–5V. טמפרטורה: T = (a·5/1023)/0.01 ≈ a·0.489 °C. מציגים H כאשר T>30°C, L כאשר T<20°C, ותצוגה ריקה בין 20 ל-30°C. בחיבור CA מקטע נדלק ב-LOW.

int seg[7] = {0,1,2,3,4,5,6}; // מקטעים a..g בהדקים D0..D6 // קודים (bit=1 → מקטע דולק): H = 0x76 (b,c,e,f,g) , L = 0x38 (d,e,f) , ריק = 0x00 void setup() { int p; for (p = 0; p < 7; p++) pinMode(seg[p], OUTPUT); } void show(unsigned char code) { // הוצאת קוד לתצוגת CA (פעיל-נמוך) int p; for (p = 0; p < 7; p++) digitalWrite(seg[p], (code & (1 << p)) ? LOW : HIGH); } void loop() { int a = analogRead(A0); float T = a * 5.0 / 1023.0 / 0.01; // טמפרטורה ב-°C if (T > 30) show(0x76); // H else if (T < 20) show(0x38); // L else show(0x00); // תצוגה ריקה }
שאלה 20 (Arduino / C) — שש נוריות ופוטנציומטר
נתונים: פוטנציומטר על A₀ (מחלק מתח 0–5V) · שש נוריות L₀–L₅ על D₂–D₇
סעיף א — מה מבצע קטע הקוד בשורות 4–7

לולאת ה-for שב-setup מגדירה את ההדקים D₂ עד D₇ (ההדקים ‎P=2 עד ‎P=7) כהדקי פלט (OUTPUT) — אלה ששת ההדקים המחוברים לנוריות.

סעיף ב — פעולת התוכנית ותפקיד הפוטנציומטר והנוריות

‎loop מדליק בזה אחר זה את הנוריות L₀…L₅ (D₂→D₇). לכל נורית התוכנית קוראת את מתח הפוטנציומטר a = analogRead(A0) (0–1023), מדליקה את הנורית ל-a·10+1000 אלפיות שנייה, ואז מכבה אותה ועוברת לבאה. זהו "אור רץ" שבו הפוטנציומטר קובע את משך ההדלקה של כל נורית — סיבוב הפוטנציומטר מאיץ או מאט את קצב המעבר בין הנוריות.

סעיף ג — שינוי שורה 11 ל-for(P=7; P>=2; P--)

כעת סדר ההדלקה מתהפך: הנוריות נדלקות מ-L₅ (D₇) כלפי מטה עד L₀ (D₂) במקום מ-L₀ כלפי מעלה. כיוון האור הרץ מתהפך.

שאלה 21 (Arduino / C) — מדידת זמני מחזור של אות
התוכנית: מודדת על הדק D₉ את משך פרק ה-'1' ואת פרק ה-'0' העוקב (במילישניות) ומשדרת את סכומם
סעיף א — הסבר השורות 5, 6, 14, 26
שורההפעולה
5pinMode(Pin, INPUT) — הגדרת הדק D₉ ככניסה לקריאת האות
6Serial.begin(9600) — אתחול תקשורת טורית אל המחשב בקצב 9600 baud
14while(digitalRead(Pin)==0); — לולאה ריקה הממתינה כל עוד האות '0', עד שהאות עולה ל-'1' (תחילת פרק ה-'1')
26סוגר הסוגריים המסולסלים של בלוק ה-if שנפתח בשורה 13 — סיום מחזור מדידה אחד
סעיף ב — פלט המחשב עבור האות הנתון

‎cnt1 סופר את משך פרק ה-'1' ו-cnt2 את משך פרק ה-'0' העוקב, כל delay(1) ≈ אלפית שנייה. באות: פרק '1' נמשך 4 שניות (‎≈4000) ופרק ה-'0' העוקב 1 שנייה (‎≈1000), ולכן:

cnt1 ≈ 4000 , cnt2 ≈ 1000 → cnt1 + cnt2 ≈ 5000
5000 5000 ...
סעיף ג — מה מבצעת התוכנית

התוכנית מודדת את משך פרק ה-'1' ואת משך פרק ה-'0' של האות שבכניסה D₉ (באלפיות שנייה), ומדפיסה את סכומם — כלומר את זמן המחזור של האות במילישניות. עבור אות זה זמן המחזור 5 שניות, ולכן מודפס ‎≈5000 שוב ושוב.

סעיף ד — מחזור הפעולה (Duty Cycle)
Duty Cycle = 100 · tonton + toff = 100 · 44 + 1 = 80%

הוספה לתוכנית (אחרי שורה 25) שתחשב ותשדר את מחזור הפעולה:

Serial.println(100.0 * cnt1 / (cnt1 + cnt2)); // → 80
Duty Cycle = 80%
שאלה 22 (Arduino / C) — רמזור להולכי רגל עם רמקול
נתונים: לחצן S על D₂ (עם R ל-+5V ← לחיצה = '0') · LED₁ אדום על D₁₀ · LED₂ ירוק על D₁₁ · רמקול על D₁₃

מצב התחלתי "עצור": אור אדום דולק והרמקול שקט. עם לחיצה על הלחצן, לאחר 10 שניות מתחלף המצב ל"עבור": הירוק דולק 30 שניות והרמקול משמיע צליל 500Hz; בתום הזמן הצליל נפסק, האדום חוזר לדלוק והמצב חוזר ל"עצור":

#define BTN 2 #define RED 10 #define GREEN 11 #define BUZZ 13 void setup() { pinMode(BTN, INPUT); // 1. הגדרת הדקים pinMode(RED, OUTPUT); pinMode(GREEN, OUTPUT); pinMode(BUZZ, OUTPUT); digitalWrite(RED, HIGH); // 2. מצב התחלתי: אדום דולק, digitalWrite(GREEN, LOW); // ירוק כבוי, noTone(BUZZ); // רמקול שקט ('0') } void loop() { if (digitalRead(BTN) == 0) // 3. לחיצה על הלחצן (פעיל-נמוך) { delay(10000); // כעבור 10 שניות – מעבר ל"עבור" digitalWrite(RED, LOW); digitalWrite(GREEN, HIGH); // אור ירוק דולק tone(BUZZ, 500); // צליל 500 Hz delay(30000); // למשך 30 שניות noTone(BUZZ); // בתום הזמן: הצליל נפסק, digitalWrite(GREEN, LOW); digitalWrite(RED, HIGH); // האדום חוזר לדלוק ("עצור") } }
🏠