מדריך | מדריך מקיף לעולם הארדואינו

[אלישי]

תוכן עניינים

1. מבוא לעולם המיקרו-בקרים
2. ארדואינו אונו - היכרות בסיסית
3. תכנות הארדואינו
4. פינים דיגיטליים ואנלוגיים
5. ESP32 ו-ESP8266
6. פרוטוקולי תקשורת
7. JavaScript וארדואינו
8. פרויקטים לדוגמה
9. טיפים מתקדמים ופתרון בעיות

1. מבוא לעולם המיקרו-בקרים

מהו מיקרו-בקר?

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

למה להשתמש במיקרו-בקר?

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

2. ארדואינו אונו - היכרות בסיסית

מהו ארדואינו?

ארדואינו הוא פלטפורמת פיתוח בקוד פתוח המבוססת על חומרה ותוכנה קלות לשימוש. הדגם הנפוץ ביותר הוא Arduino Uno.

מפרט טכני בסיסי של Arduino Uno

• מעבד: ATmega328P
• מהירות שעון: 16 MHz
• זיכרון RAM: 2KB
• זיכרון תכנית (Flash): 32KB
• פינים דיגיטליים: 14 (מתוכם 6 תומכים ב-PWM)
• פינים אנלוגיים: 6

רכיבי הלוח העיקריים

1. מחבר USB: לתכנות ואספקת חשמל
2. פינים דיגיטליים: לחיבור רכיבים שעובדים עם אותות בינאריים (0/1)
3. פינים אנלוגיים: לחיבור חיישנים שמספקים ערכים משתנים
4. כפתור Reset: להפעלה מחדש של התוכנית
5. נורת LED מובנית: מחוברת לפין דיגיטלי 13

3. תכנות הארדואינו

סביבת הפיתוח (Arduino IDE)

Arduino IDE היא תוכנה חינמית שמאפשרת לכתוב קוד, להדר אותו ולהעלות אותו לבקר.

מבנה בסיסי של תוכנית

void setup() {
  // קוד שרץ פעם אחת בהתחלה
}

void loop() {
  // קוד שרץ שוב ושוב במעגל
}

פונקציות חשובות

• pinMode(pin, mode): הגדרת פין כקלט או פלט
• digitalWrite(pin, value): כתיבת ערך HIGH/LOW לפין דיגיטלי
• digitalRead(pin): קריאת ערך מפין דיגיטלי
• analogRead(pin): קריאת ערך מפין אנלוגי
• analogWrite(pin, value): כתיבת ערך PWM לפין תומך

4. פינים דיגיטליים ואנלוגיים

פינים דיגיטליים

• מקבלים או שולחים אותות בינאריים (HIGH/LOW)
• משמשים לחיבור לחצנים, נורות LED, ממסרים
• חלק מהפינים תומכים ב-PWM לדימוי פלט אנלוגי

דוגמה לשימוש בפין דיגיטלי

void setup() {
  pinMode(13, OUTPUT);  // הגדרת פין 13 כפלט
}

void loop() {
  digitalWrite(13, HIGH);  // הדלקת LED
  delay(1000);           // המתנה לשנייה
  digitalWrite(13, LOW);   // כיבוי LED
  delay(1000);
}

פינים אנלוגיים

• קוראים ערכים משתנים (0-1023)
• משמשים לחיבור חיישנים כמו חיישני אור, טמפרטורה
• ניתן להשתמש בהם גם כפינים דיגיטליים

דוגמה לשימוש בפין אנלוגי

void setup() {
  Serial.begin(9600);  // התחלת תקשורת סיריאלית
}

void loop() {
  int sensorValue = analogRead(A0);  // קריאה מחיישן
  Serial.println(sensorValue);       // הדפסת הערך
  delay(100);
}

5. ESP32 ו-ESP8266

השוואה בין הבקרים

מאפיין	Arduino Uno	ESP8266	ESP32
מעבד	16MHz	80MHz	240MHz
RAM	2KB	160KB	520KB
WiFi	לא	כן	כן
Bluetooth	לא	לא	כן
פינים דיגיטליים	14	17	34
פינים אנלוגיים	6	1	18

יתרונות ה-ESP32

1. תקשורת אלחוטית מובנית: WiFi ו-Bluetooth
2. מעבד חזק: מאפשר משימות מורכבות יותר
3. זיכרון גדול: מתאים לפרויקטים מורכבים
4. חסכוני באנרגיה: מצבי שינה מתקדמים

6. פרוטוקולי תקשורת

סוגי תקשורת נפוצים

1. UART/Serial: תקשורת טורית פשוטה
2. I2C: תקשורת עם מספר רכיבים על שני חוטים
3. SPI: תקשורת מהירה עם רכיבים במקביל
4. WiFi: תקשורת אלחוטית (ESP32/ESP8266)

Firmata

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

7. JavaScript וארדואינו

אפשרויות לשימוש ב-JavaScript

1. Johnny-Five: ספריית Node.js לשליטה בארדואינו
2. Espruino: JavaScript על ESP32/ESP8266
3. WebSocket: תקשורת בזמן אמת בין ארדואינו לדפדפן

מגבלות

• לא ניתן להריץ Node.js ישירות על Arduino Uno
• ESP32 יכול להריץ JavaScript מוגבל
• Raspberry Pi מתאים יותר להרצת שרתי Node.js

8. פרויקטים לדוגמה

1. תחנת מזג אוויר

#include <DHT.h>

#define DHTPIN 2
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  float temp = dht.readTemperature();
  float hum = dht.readHumidity();
  
  Serial.print("Temperature: ");
  Serial.print(temp);
  Serial.println("°C");
  
  delay(2000);
}

2. בקרת LED עם חיישן אור

const int lightSensorPin = A0;
const int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int lightLevel = analogRead(lightSensorPin);
  if (lightLevel < 500) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
  delay(100);
}

9. טיפים מתקדמים ופתרון בעיות

טיפים חשובים

1. הגנה על פינים: השתמש בנגדים מתאימים
2. דיבאגינג: השתמש ב-Serial Monitor לבדיקת ערכים
3. חיסכון בחשמל: השתמש במצבי שינה בפרויקטים על סוללה
4. ספריות: חפש ספריות קיימות לפני שאתה כותב קוד חדש

פתרון בעיות נפוצות

1. הבקר לא מזוהה: בדוק את מנהל ההתקן וכבל ה-USB
2. תוכנית נתקעת: השתמש ב-watchdog timer
3. זיכרון מלא: אופטימיזציה של קוד, שימוש בזיכרון PROGMEM

משאבים נוספים

• אתר ארדואינו הרשמי
• קהילות מקומיות וגלובליות
• קורסים מקוונים וספרים מומלצים

---

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

[אלישי]

מדריך מתקדם לארדואינו אונו ו-ESP32

תוכן עניינים

1. מבוא
2. השוואה בין Arduino Uno ל-ESP32
3. ניהול זיכרון מתקדם
4. קושחות מותאמות אישית
5. MicroPython
6. תקשורת אלחוטית
7. חיישנים ופלטים מתקדמים
8. דוגמאות קוד

מבוא

Arduino Uno ו-ESP32 הם שני מיקרו-בקרים פופולריים המשמשים למגוון רחב של פרויקטים אלקטרוניים. בעוד שה-Arduino Uno מתאים למתחילים ולפרויקטים בסיסיים, ה-ESP32 מציע יכולות מתקדמות יותר כמו Wi-Fi ו-Bluetooth מובנים.

השוואה בין Arduino Uno ל-ESP32

Arduino Uno

• מעבד: ATmega328P (16 MHz)
• זיכרון RAM: 2KB
• זיכרון Flash: 32KB
• פינים דיגיטליים: 14
• פינים אנלוגיים: 6

ESP32

• מעבד: Dual-core Xtensa LX6 (240 MHz)
• זיכרון RAM: 520KB
• זיכרון Flash: עד 16MB
• פינים דיגיטליים: עד 34
• פינים אנלוגיים: עד 18
• Wi-Fi ו-Bluetooth מובנים

ניהול זיכרון מתקדם

Arduino Uno

// שימוש ב-PROGMEM לשמירת מחרוזות בזיכרון התוכנית
const char text[] PROGMEM = "טקסט ארוך שיישמר בזיכרון Flash";

// שימוש ב-malloc ו-free לניהול זיכרון דינמי
int* dynamicArray = (int*)malloc(10 * sizeof(int));
free(dynamicArray);

ESP32

// שימוש ב-PSRAM (אם קיים)
#include <esp_heap_caps.h>
void* ptr = heap_caps_malloc(1000, MALLOC_CAP_SPIRAM);

// שימוש ב-Non-Volatile Storage (NVS)
#include <Preferences.h>
Preferences preferences;
preferences.begin("my-app", false);
preferences.putInt("counter", 42);

קושחות מותאמות אישית

Arduino Uno

1. שימוש ב-Arduino IDE עם Bootloader מותאם:

avrdude -c arduino -p atmega328p -P COM3 -b 115200 -U flash:w:custom_firmware.hex

ESP32

1. בניית קושחה מותאמת עם ESP-IDF:

idf.py menuconfig
idf.py build
idf.py -p COM3 flash

2. שימוש ב-esptool לצריבת קושחה:

esptool.py --port COM3 write_flash 0x1000 custom_firmware.bin

MicroPython

התקנת MicroPython על ESP32

esptool.py --port COM3 erase_flash
esptool.py --port COM3 write_flash -z 0x1000 esp32-20220117-v1.18.bin

דוגמת קוד MicroPython

from machine import Pin
import time

led = Pin(2, Pin.OUT)

while True:
    led.value(not led.value())
    time.sleep(1)

תקשורת אלחוטית

ESP32 Wi-Fi דוגמת קוד

#include <WiFi.h>

const char* ssid = "MyNetwork";
const char* password = "MyPassword";

void setup() {
    Serial.begin(115200);
    WiFi.begin(ssid, password);
    
    while (WiFi.status() != WL_CONNECTED) {
        delay(1000);
        Serial.println("מתחבר ל-WiFi...");
    }
    
    Serial.println("מחובר!");
    Serial.println(WiFi.localIP());
}

חיישנים ופלטים מתקדמים

דוגמת קוד ל-I2C

#include <Wire.h>

void setup() {
    Wire.begin();
    Serial.begin(115200);
}

void loop() {
    Wire.beginTransmission(0x68); // כתובת I2C של החיישן
    Wire.write(0x6B);  // רגיסטר Power Management
    Wire.write(0);     // מפעיל את החיישן
    Wire.endTransmission(true);
    
    Wire.requestFrom(0x68, 14, true); // קריאת נתונים מהחיישן
    
    // עיבוד הנתונים...
}

דוגמאות קוד

דוגמה 1: מערכת RTOS על ESP32

#include <freertos/FreeRTOS.h>
#include <freertos/task.h>

void Task1(void * parameter) {
    for(;;) {
        Serial.println("Task 1");
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void Task2(void * parameter) {
    for(;;) {
        Serial.println("Task 2");
        vTaskDelay(2000 / portTICK_PERIOD_MS);
    }
}

void setup() {
    Serial.begin(115200);
    xTaskCreatePinnedToCore(Task1, "Task1", 10000, NULL, 1, NULL, 0);
    xTaskCreatePinnedToCore(Task2, "Task2", 10000, NULL, 1, NULL, 1);
}

void loop() {
    // הלולאה הראשית ריקה כי אנחנו משתמשים ב-RTOS
}

טיפים מתקדמים

1. השתמשו ב-Serial.printf() על ESP32 לפלט יעיל יותר:

Serial.printf("ערך חיישן: %d, טמפרטורה: %.2f\n", sensorValue, temperature);

2. שימוש ב-Deep Sleep למקסום חיי סוללה:

#define uS_TO_S_FACTOR 1000000  // המרה ממיקרו-שניות לשניות
#define TIME_TO_SLEEP  5        // זמן שינה בשניות

void setup() {
    esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
    esp_deep_sleep_start();
}

3. שימוש ב-watchdog timer למניעת קריסות:

#include <esp_task_wdt.h>

void setup() {
    esp_task_wdt_init(30, true); // מאתחל watchdog של 30 שניות
    esp_task_wdt_add(NULL);      // מוסיף את הליבה הנוכחית למעקב
}

void loop() {
    esp_task_wdt_reset();        // מאפס את ה-watchdog
    // קוד נוסף...
}