הצעה לפתרון מלא — אלקטרוניקה ומחשבים
בגרות · קיץ תשע"ז 2017 · שאלון 815381 · שאלות 1–14
✦ בנוי על ידי פהד גאנם ✦
💡על המסמך: הצעה לפתרון מלא לשאלון 815381 — אלקטרוניקה ומחשבים, קיץ תשע"ז 2017. בשאלון ארבע-עשרה שאלות בשלושה פרקים, ועל הנבחן לענות על חמש שאלות — אחת לפחות מכל פרק. פרק ראשון (1–4) מבוא להנדסת אלקטרוניקה; פרק שני (5–6) תורת החשמל; פרק שלישי (7–14) מבוא להנדסת מחשבים — תכנות בשפת C ובסביבת Arduino. כאן פתורות כל השאלות, לנוחות הלימוד.
🔧 פרק ראשון — מבוא להנדסת אלקטרוניקה (שאלות 1–4)
שאלה 1 — שני מגברי שרת אידיאליים (מפחית ומסכם)
נתונים: R₁=1 kΩ · R₂=2 kΩ · R₃=1 kΩ · R₄=3 kΩ · R₅=10 kΩ · R₆=20 kΩ · מקור 2V · אספקה ±12V
💡מבנה המעגל: הדק A מוארק (0V). מחלק המתח R₃–R₄ המוזן מ-2V יוצר את נקודה X, המחוברת אל הכניסה החיובית של שני המגברים. המגבר הראשון מחובר במשוב שלילי דרך R₂ (מוצא Vo1) — צירוף לא-מהפך. המגבר השני מחובר במשוב שלילי דרך R₆, וכניסתו השלילית היא הצומת שבין R₅ ל-R₆. בשני המגברים מתקיים V− = V+ = VX.
סעיף א — המתח בנקודה X
X הוא צומת מחלק המתח בין R₃ ל-R₄, המוזן ממקור 2V (כניסות המגברים אינן מושכות זרם):
VX = 1.5 V
סעיף ב — הזרם בנגד R₁ וכיוונו
במגבר הראשון קיים קצר וירטואלי, ולכן מתח הכניסה השלילית (צומת B) שווה למתח הכניסה החיובית: VB = VX = 1.5V. הדק A מוארק (VA = 0). לכן דרך R₁ עובר זרם מ-B אל A:
I(R₁) = 1.5 mA (מ-B ל-A)
סעיף ג — מתח המוצא של המגבר הראשון Vo1
A מוארק, R₁ מן ההארקה אל B, ו-R₂ במשוב מ-Vo1 אל B — צירוף לא-מהפך בעל הגבר 1 + R₂/R₁ ביחס למתח בכניסה החיובית X:
Vo1 = 4.5 V
סעיף ד — מתח-המוצא Vo
במגבר השני הכניסה החיובית היא X (1.5V), והכניסה השלילית (הצומת שבין R₅ ל-R₆) שווה לה. נכתוב את חוק הזרמים בצומת השלילי:
Vo = -4.5 V
שאלה 2 — מגבר טרנזיסטור במוצא משותף (CE) עם קבל עוקף
נתונים: VCC=12V · VCE=6V · VBE=0.7V · β=hfe=50 · hie=1.5kΩ · RE=1kΩ · RL=2kΩ · IB=10µA
סעיף א — ערך הנגד RB
זו הזנה קבועה (RB מ-VCC אל הבסיס) עם נגד אמיטר. זרם האמיטר IE = (β+1)·IB = 51 × 10µA = 0.51mA. נכתוב את לולאת הבסיס-אמיטר:
RB ≈ 1.08 MΩ
סעיף ב — ערך הנגד RC
זרם הקולקטור IC = β·IB = 50 × 10µA = 0.5mA. נכתוב את לולאת המוצא (קולקטור-אמיטר):
RC ≈ 11 kΩ
סעיף ג — דגם החילופין הזעיר
בזרם חילופין כל הקבלים מהווים קצר. מתח המבוא Vi מגיע דרך C₁ אל הבסיס; המעבר בסיס-אמיטר מיוצג בהתנגדות hie=1.5kΩ; הקבל C₃ מקצר את RE ולכן האמיטר מוארק לחילופין; במוצא פועל מקור זרם תלוי β·ib בקולקטור, המזין את העומס RC ∥ RL. הנגד RB מחובר בין הבסיס לאדמת החילופין.
סעיף ד — הגבר המתח AV
AV ≈ -56 (מהפך)
שאלה 3 — מסנן LP, משווה ונורית LED
נתונים: E=12V · R=2 kΩ · C=1000 µF · R₁=10 kΩ · R₂=10 kΩ · VLED=1.5V · ILED=10 mA
💡מבנה המעגל: המגבר משמש כמשווה (הזנה יחידה 0–12V). הכניסה + מחוברת אל VC — מתח הקבל הנטען דרך R; הכניסה − מחוברת אל הצומת X של מחלק המתח R₁–R₂ (מתח ייחוס קבוע). מתח הקבל ההתחלתי הוא 0V, וברגע t=0 סוגרים את המפסק S. ה-LED נדלק כאשר VC עולה מעל מתח הייחוס X.
סעיף א — המתח בנקודה X
VX = 6 V
סעיף ב — סרטוט VC(t) ו-Vo(t)
מרגע סגירת המפסק הקבל נטען דרך R לפי VC(t) = 12(1 − e−t/τ), כאשר קבוע הזמן τ = R·C = 2000 × 1000µF = 2s. עקומת VC(t) עולה מעריכית מ-0 לכיוון 12V. מתח המוצא Vo נמוך (0V, LED כבוי) כל עוד VC < 6V, וברגע ש-VC חוצה את 6V הוא קופץ לרמה גבוהה (≈12V, LED דולק).
τ = 2 s ; Vo קופץ מ-0V ל-12V כאשר VC = 6V
סעיף ג — הזמן עד הדלקת ה-LED
ה-LED נדלק כאשר VC מגיע ל-6V:
t ≈ 1.39 s
סעיף ד — ההתנגדות של הנגד RL
כאשר המוצא גבוה Vo ≈ 12V. RL מגביל את זרם ה-LED:
RL = 1050 Ω
שאלה 4 — משווה עם אות משולש ומדידה באוסצילוסקופ
נתונים: אספקה יחידה 5V · מחלק 10 kΩ + 10 kΩ (ייחוס 2.5V) · אות מבוא משולש 0–5V · זמן מחזור 1 ms
💡מבנה המעגל: Vin מחובר אל הכניסה החיובית, ומחלק המתח 10kΩ–10kΩ מייצר מתח ייחוס 2.5V בכניסה השלילית. לכן מוצא המשווה גבוה (≈5V) כאשר Vin > 2.5V, ונמוך (≈0V) כאשר Vin < 2.5V.
סעיף א — חיבור שלושת המכשירים
מחברים את שלושת המכשירים כך:
מחולל-האותות: הדק ה-(+) אל מבוא המעגל Vin, והדק ה-(−) אל אדמת המעגל.
ספק-המתח (5V): הדק ה-(+) אל פס האספקה 5V (המזין את המגבר ואת מחלק המתח), והדק ה-(−) אל אדמת המעגל.
אוסצילוסקופ דו-ערוצי: ערוץ 1 — הדק ה-(+) אל Vin, הדק ה-(−) אל האדמה; ערוץ 2 — הדק ה-(+) אל Vout, הדק ה-(−) אל האדמה. כל הדקי ה-(−) משותפים לאדמה אחת.
סעיף ב — ערך ה-Time/div
למסך האוסצילוסקוֹפ עשר משבצות לרוחב. כדי להציג שני מחזורים (2 × 1ms = 2ms) על מלוא הרוחב:
Time/div = 0.2 ms/div
סעיף ג — סרטוט Vin ו-Vo
אות המבוא הוא משולש 0–5V בזמן מחזור 1ms. מוצא המשווה הוא אות מלבני בזמן מחזור זהה: גבוה (5V) בקטע שבו האות המשולש עובר את 2.5V (סביב הפסגה, כלומר 0.25ms < t < 0.75ms בכל מחזור), ונמוך (0V) בשאר המחזור (סביב הבקעים). מחזוֹר מלא של המבוא נותן מחזור מלא של המוצא ביחס מחזור 50%.
אות מלבני 0/5V, מחזור 1ms — גבוה כאשר Vin > 2.5V
🔌 פרק שני — תורת החשמל (שאלות 5–6)
שאלה 5 — מעגל RC טורי בזרם חילופין עם אמפרמטר ומפסק
נתונים: תנופה מרבית Umax=311.13V · f=1 kHz · אמפרמטר אידיאלי · מפסק S במקביל לקבל
סעיף א — המתח היעיל של המקור
Veff = 220 V
סעיף ב — ההתנגדות R (המפסק סגור)
כאשר המפסק S סגור הוא מקצר את הקבל, ובמעגל נותר רק הנגד R. מנתון Ieff = 5.5A:
R = 40 Ω
סעיף ג — היגב הקבל (המפסק פתוח)
כשהמפסק פתוח R ו-C בטור. מהזרם החדש Ieff = 4.4A נמצא את העכבה, ומתוכה את היגב הקבל:
XC = 30 Ω
סעיף ד — הקיבול של הקבל C
C ≈ 5.3 µF
שאלה 6 — רשת נגדים בזרם ישר
נתונים: R₁=2 Ω · R₂=2 Ω · R₃=4 Ω · R₄=4 Ω · R₅=6 Ω · I₂ = 2 A (בנגד R₂)
💡מבנה המעגל: מן המקור עובר R₁ אל צומת עליון, ומשם מתפצל לשני ענפים בין הצומת העליון לצומת התחתון: הענף R₂ (2Ω), והענף הטורי R₃+R₄ (4+4=8Ω) המקביל לו. מן הצומת התחתון חוזר הזרם דרך R₅ אל המקור. הזרם ב-R₁ וב-R₅ הוא זרם המקור המלא.
סעיף א — הזרם בנגד R₄
המתח על R₂ שווה למתח על הענף R₃+R₄ (הם מקבילים):
I(R₄) = 0.5 A
סעיף ב — הזרם שמספק המקור E
בצומת העליון זרם R₁ מתפצל בין R₂ לענף R₃+R₄:
I(E) = 2.5 A
סעיף ג — ההתנגדות השקולה של המעגל
Rשקולה = 9.6 Ω
סעיף ד — מתח המקור E
E = 24 V
סעיף ה1 — ההספק על כל אחד מהנגדים
P₁=12.5W · P₂=8W · P₃=1W · P₄=1W · P₅=37.5W
סעיף ה2 — סכום ההספקים שווה להספק המקור
ΣPנגדים = P(E) = 60 W
💻 פרק שלישי — מבוא להנדסת מחשבים (שאלות 7–14) · שפת C ו-Arduino
שאלה 7 (C) — קריאת מפסקים והפעלת שמונה נוריות
חומרה: מפתח-קלט 300H (מפסקים S₀,S₁ על D₀,D₁) · מפתח-פלט 301H (שמונה נוריות D₀–D₇)
💡מצב המפסקים: כל מפסק מחובר אל +5V, ונגד-מטה (pull-down) אל האדמה. לכן מפסק סגור → הביט 1, מפסק פתוח → הביט 0. בפלט: כל נורית נדלקת כאשר הביט המתאים הוא 1 (0xFF = כל הנוריות דולקות, 0x00 = כבויות).
התוכנית בשפת C
void main(void)
{
int in, i;
while (1)
{
in = Inp32(0x300) & 0x03; /* read the two switches, mask D2..D7 */
if (in == 0x03) /* both switches open -> all LEDs on */
Out32(0x301, 0xFF);
else if (in == 0x00) /* both switches closed -> all LEDs off */
Out32(0x301, 0x00);
else /* exactly one switch closed -> blink */
{
for (i = 0; i < 10; i++) /* blink 10 times */
{
Out32(0x301, 0xFF);
delay(500);
Out32(0x301, 0x00);
delay(500);
}
}
}
}
הפעולה Inp32(0x300) & 0x03 מבודדת את שני הביטים D₀,D₁ בלבד (מיסוך שאר המבואות). שלושת המצבים נבדקים לפי הערך המתקבל: 0x03 (שניהם פתוחים), 0x00 (שניהם סגורים), וכל ערך אחר (0x01 או 0x02) פירושו מפסק אחד סגור והשני פתוח — ואז לולאת ה-for מהבהבת את כל הנוריות עשר פעמים בהשהיה בין הדלקה לכיבוי.
שאלה 8 (C) — מערך, איברים במקומות אי-זוגיים וסכומם
הפעולות: הגדרת מערך של עשרה שלמים, קליטה, הדפסה, איברים אי-זוגיים וסכומם
💡מקומות אי-זוגיים: בשפת C האינדקסים מתחילים מ-0, ולכן המקומות האי-זוגיים הם אינדקסים 1, 3, 5, 7, 9.
התוכנית בשפת C
#include <stdio.h>
void main(void)
{
int arr[10]; /* 1 - array of ten integers */
int i, sum_ez = 0;
/* 2 - read from keyboard, fill the array and print the values */
for (i = 0; i < 10; i++)
{
scanf("%d", &arr[i]);
printf("%d ", arr[i]);
}
printf("\n");
/* 3 - print the whole array in one row, one space between values */
printf("arr : ");
for (i = 0; i < 10; i++)
printf("%d ", arr[i]);
printf("\n");
/* 4 - print, on the next row, the elements at odd positions */
for (i = 1; i < 10; i += 2)
printf("%d ", arr[i]);
printf("\n");
/* 5 - sum of the elements at odd positions */
for (i = 1; i < 10; i += 2)
sum_ez += arr[i];
printf("sum ez = %d\n", sum_ez);
}
שורות 4–5 (הלולאה עם i += 2 החל מ-1) עוברות על המקומות האי-זוגיים בלבד: תחילה מדפיסות אותם בשורה, ואחר-כך צוברות את סכומם ל-sum_ez ומדפיסות אותו בתבנית sum ez = ... בתחתית.
שאלה 9 (C) — ספירת מפסקים סגורים ותצוגה על 7-Segment
חומרה: שמונה מפסקים על מפתח-קלט 300H · תצוגת 7-seg בחיבור קתודה משותפת (CC) על מפתח-פלט 301H
קטע הקוד הנתון
void main(void)
{
int arr[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F};
int i,in,t;
while (1)
{
t = 0;
in = Inp32(0x300);
for (i = 0; i < 8; i++)
{
if ((in & 1) == 1) t = t + 1;
in = in >> 1;
}
Out32(0x301, arr[t]);
}
}
סעיף א — הסבר השורות 8, 11, 12, 14
שורה 8: in = Inp32(0x300) — קוראת את מצב שמונת המפסקים ממפתח-הקלט 300H אל המשתנה in.
שורה 11: if ((in & 1) == 1) t = t + 1 — בודקת את הביט הימני ביותר; אם המפסק הנוכחי סגור (הביט 1), מגדילה את המונה t.
שורה 12: in = in >> 1 — הזזה ימינה כדי לבחון את המפסק הבא.
שורה 14: Out32(0x301, arr[t]) — מוציאה אל תצוגת ה-7-seg את הקוד arr[t], כלומר את הספרה השווה למספר המפסקים הסגורים.
המערך arr מכיל את קודי ה-7-seg (קתודה משותפת) של הספרות 0–8, ולכן התוכנית מציגה את מספר המפסקים הסגורים.
סעיף ב — התצוגה כאשר S₁, S₃, S₅, S₇ סגורים
ארבעה מפסקים סגורים ושאר המפסקים פתוחים, ולכן t = 4. מתקבל arr[4] = 0x66 — קוד הספרה 4:
התצוגה מראה את הספרה 4
סעיף ג — מעבר לחיבור אנודה משותפת (CA)
בתצוגת אנודה משותפת קטע נדלק כאשר מזינים אותו ב-0 (פעולה משלימה לקתודה משותפת). כדי לשמר את אותה תצוגה, יש להוציא את הקוד המשלים. משנים את שורה 14:
Out32(0x301, arr[t] ^ 0xFF); /* invert all 8 bits for common-anode */
הפעולה arr[t] ^ 0xFF (או ~arr[t] & 0xFF) הופכת כל ביט, כך שאותם קטעים בדיוק נדלקים — והפלט הנראה אינו משתנה מהחלפת התצוגה.
שאלה 10 (C) — היפוך ספרות של מספרים דו-ספרתיים
קליטה: עד עשרה מספרים שלמים בטווח 0–99 · לכל מספר מחשבים את היפוך ספרותיו
קטע הקוד הנתון
#include <stdio.h>
void main(void)
{
int arr1[10], arr2[10];
int cnt = 0, i;
while (cnt < 10)
{
scanf("%d", &i);
if ((i >= 0) && (i < 100))
{
arr1[cnt] = i;
cnt++;
}
}
for (i = 0; i < 10; i++)
{
arr2[i] = (arr1[i] / 10) + ((arr1[i] % 10) * 10);
printf("%d-->%d\n", arr1[i], arr2[i]);
}
}
סעיף א — הסבר השורות 4, 6, 9, 17
שורה 4: int arr1[10], arr2[10] — הגדרת שני מערכים בני עשרה איברים שלמים.
שורה 6: while (cnt < 10) — הלולאה נמשכת עד שנקלטו עשרה מספרים תקינים.
שורה 9: if ((i >= 0) && (i < 100)) — מסננת: רק מספרים בטווח 0–99 מתקבלים ונשמרים; מספרים מחוץ לטווח מושמטים.
שורה 17: arr2[i] = (arr1[i]/10) + ((arr1[i]%10)*10) — מחליפה בין ספרת העשרות לספרת האחדות (היפוך המספר הדו-ספרתי).
סעיף ב — הפלט עבור רצף הקלט
רצף הקלט (משמאל לימין): 16, 21, 145, 45, 50, 1, 10, 0, 23, 256, 14, 73. המספרים 145 ו-256 נדחים (מחוץ לטווח 0–99), ולכן עשרת המספרים שנשמרים ב-arr1 הם: 16, 21, 45, 50, 1, 10, 0, 23, 14, 73. לכל מספר מוחלפות הספרות:
16-->61
21-->12
45-->54
50-->5
1-->10
10-->1
0-->0
23-->32
14-->41
73-->37
סעיף ג — הצגת האיבר הגדול ביותר ב-arr2
מוסיפים בסוף התוכנית קטע-קוד המוצא את הערך המרבי במערך arr2:
int max = arr2[0];
for (i = 1; i < 10; i++)
if (arr2[i] > max)
max = arr2[i];
printf("max = %d\n", max); /* -> 61 */
האיבר הגדול ביותר ב-arr2 הוא 61
שאלה 11 (Arduino) — בקרת נורית RGB לפי שלושה מפסקים
חומרה: SW₀,SW₁,SW₂ בהדקים 2,3,4 · נוריות RED,GREEN,BLUE ב-PB₁,PB₂,PB₃ (הדקים 9,10,11)
💡מצב המפסקים: כל מפסק מחובר אל 5V עם נגד-מטה, ולכן מפסק סגור → HIGH, מפסק פתוח → LOW. אם SW₀ פתוח — שלוש הנוריות כבויות; אם SW₀ סגור — הצבע נקבע לפי SW₁ ו-SW₂ (לפי טבלת המצבים).
התוכנית בשפת C (Arduino)
#define SW0 2
#define SW1 3
#define SW2 4
#define RED 9
#define GREEN 10
#define BLUE 11
void setup()
{
pinMode(SW0, INPUT); pinMode(SW1, INPUT); pinMode(SW2, INPUT);
pinMode(RED, OUTPUT); pinMode(GREEN, OUTPUT); pinMode(BLUE, OUTPUT);
}
void loop()
{
int s0 = digitalRead(SW0);
int s1 = digitalRead(SW1);
int s2 = digitalRead(SW2);
/* default - all LEDs off */
digitalWrite(RED, LOW);
digitalWrite(GREEN, LOW);
digitalWrite(BLUE, LOW);
if (s0 == HIGH) /* SW0 closed */
{
if (s1 == LOW && s2 == LOW) digitalWrite(RED, HIGH);
else if (s1 == LOW && s2 == HIGH) digitalWrite(GREEN, HIGH);
else if (s1 == HIGH && s2 == LOW) digitalWrite(BLUE, HIGH);
else /* s1 == HIGH && s2 == HIGH */
{
digitalWrite(RED, HIGH);
digitalWrite(GREEN, HIGH);
digitalWrite(BLUE, HIGH);
}
}
}
| SW1 | SW2 | נוריות שנדלקות |
|---|
| open (LOW) | open (LOW) | RED |
| open (LOW) | closed (HIGH) | GREEN |
| closed (HIGH) | open (LOW) | BLUE |
| closed (HIGH) | closed (HIGH) | RED, GREEN, BLUE |
שאלה 12 (Arduino) — חיישן אור LDR וממיר A/D
חומרה: LDR מ-5V, נגד 20 kΩ אל האדמה, הצומת A₀ · נורית LED ב-PB₁ (הדק 9) · ממיר A/D בעל 10 סיביות
סעיף א — המתח בהדק A₀ בהארה 6 lux
מהגרף, בהארה של 6 lux ההתנגדות של ה-LDR היא RLDR = 20 kΩ. המתח בהדק A₀ נקבע ממחלק המתח בין ה-LDR לנגד 20kΩ:
VA₀ = 2.5 V
💡ככל שההארה גדֵלה, RLDR קטֵנה ולכן VA₀ עולה. סף ההארה 6 lux מתאים ל-2.5V, כלומר לקריאת ממיר analogRead ≈ 2.5/5 × 1023 ≈ 511. הארה גדולה מ-6 lux → קריאה גדולה מ-511.
סעיף ב — התוכנית בשפת C (Arduino)
#define analogPin A0
#define ledPin 9
int val;
void setup()
{
pinMode(ledPin, OUTPUT);
}
void loop()
{
val = analogRead(analogPin); /* 1 - read the analog voltage at A0 (0..1023) */
if (val > 511) /* V(A0) > 2.5V <=> illumination > 6 lux */
digitalWrite(ledPin, HIGH); /* 2 - LED on */
else
digitalWrite(ledPin, LOW); /* LED off (illumination <= 6 lux) */
}
הנורית נדלקת כאשר ההארה גדולה מ-6 lux (המתח בהדק A₀ עולה מעל 2.5V, כלומר הקריאה עולה מעל 511), ונכבית כאשר ההארה שווה ל-6 lux או קטנה ממנו.
שאלה 13 (Arduino) — הזזת נורית דולקת לפי תווים מהמקלדת
חומרה: PB₀–PB₅ (הדקים 8–13) המחוברים לשש נוריות LED דרך נגדי 220 Ω
קטע הקוד הנתון
byte c, out;
void setup()
{
Serial.begin(9600);
DDRB = 0x3F;
out = 1;
PORTB = out;
}
void loop()
{
if (Serial.available() > 0)
{
c = Serial.read();
if (c == '+') out = out << 1;
if (out == 0x20) out = 1;
PORTB = out;
}
}
סעיף א — הסבר השורות 4, 5, 11, 15
שורה 4: Serial.begin(9600) — אתחול תקשורת טורית בקצב 9600 סיביות לשנייה.
שורה 5: DDRB = 0x3F — הגדרת ההדקים PB₀–PB₅ (הביטים 0–5, 0x3F = 00111111) כמוצאים.
שורה 11: if (Serial.available() > 0) — בדיקה אם התקבל תו כלשהו בכניסה הטורית.
שורה 15: if (out == 0x20) out = 1 — כאשר הביט הדולק מגיע ל-PB₅ (0x20), מאפסים חזרה ל-PB₀ (0x01) עוד לפני ההוצאה ל-PORTB.
סעיף ב — טבלת המעקב אחר המשתנה OUT
| לחיצות על "+" | OUT | הנורית הדולקת |
|---|
| לפני התחלת הלחיצות | 0x01 | LED0 |
| אחרי הלחיצה הראשונה | 0x02 | LED1 |
| אחרי הלחיצה השנייה | 0x04 | LED2 |
| אחרי הלחיצה השלישית | 0x08 | LED3 |
| אחרי הלחיצה הרביעית | 0x10 | LED4 |
| אחרי הלחיצה החמישית | 0x01 | LED0 |
| אחרי הלחיצה השישית | 0x02 | LED1 |
סעיף ג — האם ניתן להדליק את LED5
לא. ברגע ש-out מגיע לערך 0x20 (הביט של LED5), שורה 15 מאפסת אותו ל-0x01 עוד לפני ההוצאה ל-PORTB, ולכן LED5 לעולם אינו נדלק. כדי שגם LED5 יידלק, יש לשנות את סף האיפוס בשורה 15 ל-0x40:
if (out == 0x40) out = 1; /* now 0x20 (LED5) is displayed before wrapping */
כך הערך 0x20 מוצא אל PORTB (LED5 נדלק), ורק ההזזה הבאה (0x40, שאין לו נורית) מאפסת חזרה ל-0x01.
שאלה 14 (Arduino) — יצירת אות PWM לפי פוטנציומטר
חומרה: פוטנציומטר בהדק A₀ · מוצא "out" ב-PB₅ (הדק 13) · ממיר A/D בעל 10 סיביות
קטע הקוד הנתון
#define analogPin A0
#define outPin 13
int analogValue;
void setup()
{
pinMode(outPin, OUTPUT);
}
void loop()
{
analogValue = analogRead(analogPin) / 100;
digitalWrite(outPin, HIGH);
delay(analogValue);
digitalWrite(outPin, LOW);
delay(10 - analogValue);
}
סעיף א — הסבר השורות 2, 6, 10, 12
שורה 2: #define outPin 13 — הגדרת קבוע בשם outPin המייצג את הדק 13.
שורה 6: pinMode(outPin, OUTPUT) — הגדרת הדק 13 כמוצא.
שורה 10: analogValue = analogRead(analogPin) / 100 — קריאת המתח האנלוגי ב-A₀ (ערך 0–1023) וחלוקתו ב-100 (חלוקה שלמה) לקבלת ערך שלם 0–10.
שורה 12: delay(analogValue) — השהיית המוצב במצב HIGH למשך analogValue אלפיות-שנייה.
סעיף ב — תחום הערכים של analogValue
הפעולה analogRead מחזירה 0–1023; חלוקה שלמה ב-100 נותנת 1023/100 = 10 לכל היותר:
analogValue מקבל ערכים שלמים בתחום 0 – 10
סעיף ג — צורת הגל בהדק 13
התוכנית יוצרת אות PWM בזמן מחזור קבוע של 10ms, שבו משך ה-HIGH הוא analogValue ומשך ה-LOW הוא (10 − analogValue). לכל מתח בהדק A₀:
בכל המקרים זמן המחזור 10ms; יחס ה-HIGH: 2ms · 5ms · 7ms