על המסמך: הצעה לפתרון מלא לשאלון 815381 — אלקטרוניקה ומחשבים, קיץ תשע"ט 2019. השאלון בנוי משני חלקים: חלק א' (שאלות 1–8, לתוכנית הלימודים החדשה) ובו פרק ראשון (תורת החשמל), פרק שני (אלקטרוניקה תקבילית וספרתית) ופרק שלישי (תכנות ב-C#); חלק ב' (שאלות 9–22, לתוכנית הלימודים הישנה) ובו פרק רביעי (מבוא לאלקטרוניקה), פרק חמישי (תורת החשמל) ופרק שישי (מבוא להנדסת מחשבים — תכנות ב-C ו-Arduino). כמה שאלות בחלק ב' זהות לשאלות בחלק א' — הדבר צוין בכל מקום. כאן פתורות כל השאלות, לנוחות הלימוד.
🔌 חלק א' · פרק ראשון — יסודות תורת החשמל (שאלות 1–2)
מבנה המעגל: 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₁ הוא הזרם הכולל של המקור — סכום הזרמים בשני הענפים המקבילים:
הנחה: מד-הזרם מודד את זרם הפולט. מכיוון ש-β גדול נהוג לקרב 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 מחובר בין הבסיס לאדמת החילופין.
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
🧪סימולציה בתוך הדף— מגבר הפרש — שני מקדמים
המוצא הוא 1.5·V₁ פחות 2·V₂. בערכי השאלון — סעיף ב: V₁ = 2 V ו-V₂ = 0, והמוצא 3 V. גררו את V₁ לאורך הקו הישר.▶ פתח את מעבדת מגברי השרת
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — מגבר הפרש — שני מקדמים.
שאלה 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.
תחום VC
Vo1
Vo2
LED
VC < 2V
0V
6V
כבוי
2V < VC < 4V
0V
0V
כבוי
VC > 4V
6V
0V
דולק
סעיף ד — תחום עוצמת ההארה (lux) שבו ה-LED דולק
התנאי VC > 4V שקול, דרך מחלק המתח VC = 6·20/(RLDR+20), לתנאי על התנגדות ה-LDR:
6 · 20RLDR + 20 > 4 → RLDR < 10 kΩ
מהגרף (התנגדות ה-LDR מול עוצמת ההארה), התנגדות של 10kΩ מתקבלת בעוצמת הארה של כ-10 lux. התנגדות ה-LDR קטנה מ-10kΩ בהארות חזקות יותר, ולכן ה-LED דולק בעוצמת הארה גדולה מכ-10 lux (בערך התחום 10–20 lux בגרף).
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — LDR עם שני משווים.
💻 פרק שלישי — תכנות בשפת 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:
סעיף ג — קטע קוד: סדרה חשבונית 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;
}
🧪סימולציה בתוך הדף—C# — המחלקה ArithmeticSeries
בערכי השאלון מתקבל פלט קטע הקוד: 3, 5, 7, sum3=15, 17. שנו את ההפרש וראו את כל הסדרה זזה.▶ פתח את פרק יסודות C#
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — C# — המחלקה ArithmeticSeries.
התוכנית קולטת עבור כל רוכש את כמות השוברים הבודדים והכפולים, מציגה את הסכום לתשלום והודעה אם מגיע שובר חינם, וממשיכה עד שנקלט הערך −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);
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — C# — מכירת שוברים.
שאלה 8 (C#) — פלינדרום ארבע-ספרתי (IsPalindrome4)
נתון: הפעולה IsPalindrome4(num) מחזירה true אם המספר הוא פלינדרום בן ארבע ספרות בדיוק
סעיף א — הפלט של קטע הקוד
הלולאה רצה עד שנספרו שלושה פלינדרומים (b=3). נבדוק כל קלט (קריאה משמאל לימין): b סופר פלינדרומים, c סופר את השאר:
תנאי הלולאה b!=3
a
התנאי IsPalindrome4(a)
b
c
פלט
אתחול
—
—
0
0
—
מתקיים
9119
מתקיים
1
0
—
מתקיים
1111
מתקיים
2
0
—
מתקיים
24
לא מתקיים
2
1
—
מתקיים
575
לא מתקיים
2
2
—
מתקיים
1331
מתקיים
3
2
—
לא מתקיים
—
—
3
2
Total number of inputs:5 Total 4 digit palindrome inputs:3
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);
בחיבור המפסקים: מפסק סגור ← +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. הצגת מספר המפסקים הפתוחים
}
}
🧪סימולציה בתוך הדף— C — מפסקים ותצוגת 7-seg
קבעו כל מפסק כפתוח או כסגור: התצוגה מראה כמה מפסקים פתוחים, וכששמונתם פתוחים הספרה 8 מהבהבת שלוש פעמים.▶ פתח את פרק המערכות המשובצות
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — C — מפסקים ותצוגת 7-seg.
שאלה 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);
הערת דפוס: בלולאה שבשורה 6 מופיעים פסיקים במקום נקודה-פסיק, והתנאי הוא i<10 אף שב-arr2 יש 9 איברים (אינדקסים 0–8). הכוונה היא for(i=0; i<9; i++) — מעבר על תשעת האיברים. כך פתרנו.
סעיף א — הסבר השורות 8, 9, 10, 12
שורה
הפעולה
8
x = arr2[i] & 0x01 — בידוד הסיבית הנמוכה (LSB, bit0) של האיבר
9
y = (arr2[i] & 0x80) >> 7 — בידוד הסיבית הגבוהה (MSB, bit7) והזזתה למקום 0 (0 או 1)
10
if (x==y) t++ — אם MSB שווה ל-LSB, מגדיל את המונה t
12
out32(0x301, arr1[t]) — שולח לתצוגה את קוד ה-7-seg של הספרה t
סעיף ב — הערך שיופיע בתצוגה בסיום
t סופר כמה מאיברי arr2 מקיימים bit0 = bit7. נבדוק את תשעת האיברים:
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):
בחיבור CA מקטע נדלק כאשר הפלט '0' (פעיל-נמוך) — היפוך של CC. לכן משלימים את קוד הפלט (כך המראה בתצוגה נשאר זהה). משנים את שורה 12:
12. out32(0x301, ~arr1[t]); // השלמה סיבית-סיבית עבור CA
🧪סימולציה בתוך הדף— C — השוואת bit0 ל-bit7 במערך
מעבר אחד על תשעת איברי arr2: איבר שבו bit0 שווה ל-bit7 מגדיל את t, והספרה t מוצגת. שנו את שני האיברים הראשונים כדי להגיע ל-9.▶ פתח את פרק המערכות המשובצות
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — C — השוואת bit0 ל-bit7 במערך.
שאלה 18 (C) — מציאת ערך מרבי בקלט
התוכנית: קולטת מספרים שלמים עד שנקלט מספר שאינו חיובי, ומחזיקה ב-x את הערך הגדול ביותר
⚠️
הערת דפוס: בשורה 5 מופיעה נקודה-פסיק אחרי ה-while: while(i > 0);. כלשונה, זו לולאה ריקה אינסופית (הקלט הראשון 4 חיובי), והתוכנית אינה מדפיסה דבר נוסף. הכוונה היא while(i > 0) ללא נקודה-פסיק. כך פתרנו.
סעיף א — הסבר השורות 4, 5, 7, 8
שורה
הפעולה
4
x = i — אתחול x בערך הקלט הראשון (x יחזיק את המרבי)
5
while(i > 0) — הלולאה נמשכת כל עוד הקלט חיובי; נעצרת בקלט אפס או שלילי
7
if (i > x) x = i — עדכון המרבי אם הקלט הנוכחי גדול מ-x
8
printf("Enter int number: ") — הצגת הודעת בקשה לקליטת המספר הבא
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
🧪סימולציה בתוך הדף— C — מציאת הערך המרבי
x מאותחל בקלט הראשון, והקליטה נעצרת בקלט שאינו חיובי — העמודות האפורות לא השתתפו בחישוב. החליפו את התנאי ל-i < x וקבלו את המזערי.▶ פתח את פרק המערכות המשובצות
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — C — מציאת הערך המרבי.
שאלה 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] = {6,5,4,3,2,1,0}; // מקטעים a..g בהדקים D6..D0
// קודים (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); // תצוגה ריקה
}
🧪סימולציה בתוך הדף— ארדואינו — LM35 ותצוגת H / L
עשרה מיליוולט לכל מעלה: מעל 30°C מוצגת H, מתחת ל-20°C מוצגת L, וביניהן התצוגה ריקה.▶ פתח את פרק החיישנים
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — ארדואינו — LM35 ותצוגת H / L.
שאלה 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
שורה
הפעולה
5
pinMode(Pin, INPUT) — הגדרת הדק D₉ ככניסה לקריאת האות
6
Serial.begin(9600) — אתחול תקשורת טורית אל המחשב בקצב 9600 baud
14
while(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 שוב ושוב.
התוכנית סופרת אלפיות שנייה בכל מצב של האות; סכום שני המונים הוא זמן המחזור, והיחס ביניהם נותן את מחזור הפעולה.▶ פתח את פרק המערכות המשובצות
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — ארדואינו — מדידת זמני מחזור.
שאלה 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); // האדום חוזר לדלוק ("עצור")
}
}
🧪סימולציה בתוך הדף— ארדואינו — רמזור להולכי רגל
עברו בין שלושת השלבים: עצור, עשר שניות של המתנה אחרי הלחיצה, ועבור — אור ירוק וצליל של 500 Hz למשך 30 שניות.▶ פתח את פרק המערכות המשובצות
🧪 בגרסת האתר יש כאן סימולציה אינטראקטיבית — ארדואינו — רמזור להולכי רגל.