חיבור ESP32 ל-Arduino IDE וקבלת מידע לקונסולה

בפוסט הזה אני אסביר על איך מחברים מיקרובקר מסוג ESP32 לעורך קוד מסוג Arduino IDE וכתיבת קוד ב-Arduino Sketch שהיא סבסט של ++C. מדובר בקוד שהוא מעט יותר מסורבל ממיקרופייתון אבל כן מאפשר לנו לכתוב קוד יעיל יותר וכן הספריות הרבות שיש לארדואינו מאד מסייעות. כמו כן, בעולם ה-AIoT, כשמשתמשים במיקרובקרים, יותר קל לפעמים לעבוד על ++C.

אני מניח שיש לכם ידע ב-ESP32 ואתם יודעים מה זה וגם איך לחבר רכיבים ומה זה GPIO. מי שלא – יכול להכנס לפוסט הזה שבו אני מסביר מאפס מה זה המיקרו הבקר הזול במיוחד הזה ואיזה ציוד מגיע איתו. שם יש הסבר על מיקרופייתון שהיא דרך מאד קלה לכתוב ולעבוד עם ESP32. אבל כשנכנסים למגרש של הגדולים ולעולם ה-AI, עדיף לעבוד עם ארדואינו Sketch. אני אסביר על איך לעבוד איתו ואיך לבנות חיישן… גזים. כן.

נתחיל בתוכנה עצמה. יש להתקין את Arduino IDE. היא עובדת גם בחלונות וגם במק. אחרי ההתקנה, יש להתקין את הדרייבים של הלוחות של ESP32. כיוון שאנחנו עובדים ישירות על החומרה, ללא החומרה של הלוחות לא נוכל להתחבר ולעבוד על ESP32. חברת ESPREESSIF, החברה שמייצרת את ESP32, מספקת אותם וגם דף התקנה.

אנחנו נפעיל את ה-Arduino IDE ונלך על Settings ומשם ל-Additional Boards Manager URL – נכניס את הקישור שיש בדף ההתקנה – https://espressif.github.io/arduino-esp32/package_esp32_index.json

אחרי כמה דקות, נוכל להתחיל לעבוד עם ESP32. נחבר את ה-ESP32 ונלחץ על Select Board. אם יש לנו כמה חיבורים שם – ננתק את ה-ESP32 ונראה מה התנתק. בד״כ זה יהיה usbserial-0001 או מספר אחר.

אנחנו נגיע אל המקום שבו בוחרים את הלוח עצמו. פה אנחנו נחפש ESP32-WROOM ונבחר את מה שיש שם. מודל DA זה בסדר גמור.

ו… זהו! עכשיו בעצם אנחנו יכולים להריץ קוד. הרצת הקוד היא פשוטה. בואו ונתחיל עם קוד Hello World פשוט שמדפיס לקונסולה וגם גורם ל-LED הפנימי להבהב. רק בשביל לראות שהכל בסדר.

שימו לב : בעולם ה-IoT והמיקרובקרים מאד קל להתלהב ולבקש מ-ChatGPT לייצר קוד מסובך בהתחלה. אבל עצה שלי – במיוחד בעולם הבינה המלאכותית – לכו בצעדים קטנים. קודם לוודא חיבור ולעשות איזה Hello World. אני ממליץ להשתמש בקוד הזה שמדפיס Hello World ומהבהב ב-LED.

/*
  ESP32 Hello World with Serial and Blinking LED
  This example prints "Hello, World!" to the serial monitor and
  continuously blinks an LED connected to GPIO2.
*/

const int ledPin = 2;  // Use 2 for the onboard LED; change if needed

void setup() {
  // Initialize serial communication at 115200 baud
  Serial.begin(9600);
  // Allow time for the serial monitor to connect
  delay(1000);
  
  // Print a welcome message once during setup
  Serial.println("Hello, World!");
  
  // Configure the LED pin as an output
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Turn the LED on
  digitalWrite(ledPin, HIGH);
  delay(500);  // Wait 500 milliseconds

  // Turn the LED off
  digitalWrite(ledPin, LOW);
  delay(500);  // Wait 500 milliseconds
}

אחרי שתכניסו את הקוד הזה, אנחנו נלחץ על כפתור ה-Play. ה-IDE יג׳נרט את הקוד ויעלה אותו. זה יקח כדקה או שתיים.

אחרי שהכל יושלם, אנחנו נראה שהמיקרובקר שלנו מתחיל להבהב. אבל איפה הקונסולה? אנחנו נלחץ על ״Tools״ ואז על Serial Monitor.

יופיע למטה ה-Serial Monitor. אנחנו נראה Hello World.

שימו לב :– הקונסולה עובדת ב-באוד (Baud) מסוים. לאלו מביניכם שלא נולדו בשנות ה-80 – באוד הוא יחידת מידה המשמשת למדידת קצב העברת נתונים בתקשורת דיגיטלית. היחידה מתארת את מספר האותות (לא ביטים! אות יכול להכיל יותר מביט אחד) שעוברים בערוץ התקשורת בשנייה אחת. לפני מיליון שנה בערך, באוד היתה נפוצה במיוחד במדידת קצבי שידור של מודמים. למה זה חשוב? כי ליד המוניטור של ה-Serial יש לנו את הקצב של הבאוד. אם הוא לא יהיה תואם למה שיש בקוד, נקבל ג׳יבריש. כיוון שהגדרנו בקוד שידור של 9600 באוד בקוד הזה:

  Serial.begin(9600);

אנחנו חייבים לוודא שהמוניטור שלנו קולט ב-9600.

חיבור חיישן הגזים

אם הכל עובד אז מעולה. בואו נראה איך מחברים חיישן גזים! חיישני גזים הם חיישני MQ ויש לא מעט כאלו בעלי אקספרס שעולים לא המון כסף – כשני דולר לחיישן. אני מאד אוהב להשתמש בחיישן MQ4 שקולט את גז המתאן – גז עם ניחוח אופייני שניתן למצוא בשירותים – בזה משתמשים על מנת לבדוק… פלוצים. סליחה

שימו לב : אם לא עבדתם עם חיישני גזים בעבר, שימו לב שאת רובם חייבים לחבר למתח של 5V (כלומר להשתמש ב-ESP32 שיש בו פין של 5V) ולתת להם זמן להתחמם. באלו שאני משתמש יש שני LEDS. אחד אדום, שמסמן על מתח והשני ירוק, שמראה על הכנה לפעולה. זה לא עובד ככה בכל החיישנים אבל שימו לב שאם משהו לא עובד לכם כשורה – אתם תמיד מקבלים קריאה של 4000 או רואים ג׳יבריש בקונסולה גם אם הקפדתם על הבאוד? אז מהניסיון שלי – זו הבעיה שלכם.

החיבור הוא פשוט – את המתח נחבר ל-5V, את הגראונד נחבר לגראונד ואת ה-AO שהוא הפלט האנלוגי, נחבר ל-GPIO מספר 34 שתומך בפלט אנלוגי. אם אתם לא יודעים מה זה פינים או GPIO – מדובר בפינים שנמצאים על המיקרו בקר והם משמשים אותנו לחיבור של אמצעי קלט או פלט (במקרה הזה קלט), מתח וגראונד. אני מסביר על GPIO יותר לעומק בפוסט הזה. בגדול – חיבור כבלים קטנים שנקראים ג׳אמפרים על הפינים. מפה של הפינים של המיקרובקר שלכם אפשר למצוא כשמחפשים GPIO pinout map ESP32. שימו לב שיש כמה דגמים של ESP32 וגם יש מספר פינים שונה – אתרו את שלכם.

החיישן מוכן? בואו ונבדוק! נכניס את הקוד הזה לארדואינו IDE – כאמור קוד שג׳ינרטתי ב-ChatGPT אבל הוא מאד מבודד ורק מדפיס את התוצאה של החיישן לקונסולה:

const int mq4Pin = 34; // ADC-capable pin where the MQ-4 sensor is connected

void setup() {
  // Start the Serial Monitor at 115200 baud rate
  Serial.begin(9600);
  
  delay(1000);
  
  // Set the sensor pin as input (not strictly necessary since analogRead() handles this)
  pinMode(mq4Pin, INPUT);

  Serial.println("MQ-4 sensor reading initialized. Allow sensor to warm up...");
}

void loop() {

  int sensorValue = analogRead(mq4Pin);

  // Print the sensor reading to the Serial Monitor
  Serial.print("MQ-4 sensor reading: ");
  Serial.println(sensorValue);

  // Wait for 1 second before reading again
  delay(1000);
}

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

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

אבל אם הכל עובד אפשר לעשות דברים מעניינים. למשל… מה עם להפעיל את ה-LED בכל פעם שיש ניחוח עשיר? אנחנו נגדיר סף (או Threshold באנגלית) של מספר מסוים – למשל 2000. אם אנחנו עוברים אותו? ה-LED יתחיל להאיר.

const int mq4Pin = 34;      // ADC-capable pin for the MQ-4 sensor
const int ledPin = 2;       // LED pin (commonly built-in on many ESP32 boards)
const int threshold = 2000; // Threshold value above which the LED will blink

void setup() {
  Serial.begin(9600);
  analogReadResolution(12); // Set ADC resolution to 12 bits (0 to 4095)
  
  // Set up the sensor and LED pins
  pinMode(mq4Pin, INPUT);
  pinMode(ledPin, OUTPUT);
  
  Serial.println("MQ-4 sensor reading initialized. Allow sensor to warm up...");
}

void loop() {
  int sensorValue = analogRead(mq4Pin);  // Read the raw analog value from the sensor
  Serial.print("MQ-4 sensor reading: ");
  Serial.println(sensorValue);

  if (sensorValue > threshold) {
    // Blink LED: turn on for 250ms, then off for 250ms
    digitalWrite(ledPin, HIGH);
    delay(250);
    digitalWrite(ledPin, LOW);
    delay(250);
  } else {
    // If below threshold, keep LED off
    digitalWrite(ledPin, LOW);
    delay(500); // Optional: wait before next reading
  }
}

אם תפעילו אותו, תוכלו לראות אותו מהבהב בכל פעם שיש חציה של הסף המסריח שקבעתם.

אפשר כמובן לחבר אותו לנורה יותר חזקה או לבאזר (או גם וגם!) – מה שמגביל אתכם הוא החלקים שיש לכם בבית והדמיון.

או קיי, זה כמובן משהו נחמד וקצת מטופש – אבל השאלה היא איך לוקחים את זה לעולם ה-AIoT. בפוסט הבא נדבר על מתי Threshold זה לא מספיק ולמה צריך לאסוף דאטהסט כדי לאמן מודל.