ESP32 Modbus Master TCP: 7 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:15

בשיעור זה, תתכנת את מעבד ESP32 כ- Masterbus TCP Master.

נשתמש בשני מכשירים המכילים מעבד זה: Moduino ESP32 ו- Pycom. שני המכשירים פועלים בסביבת MicroPytthon. ה- Modbus Slave שלנו יהיה מחשב PC עם תוכנת סימולטור מודבוס שרצה עליו.

אתה תצטרך:

• Moduino ESP32 או מכשיר Moduino Pycom (בדוק באתר זה למידע נוסף על מכשיר Moduino ESP32 וזאת לבדיקת מכשיר Pycom)
• מחשב עם מערכת הפעלה לינוקס
• יציאת RS-232/RS-485 במחשב או ממיר USB ל- RS-232/RS-485

שלב 1: הורד והפעל Simulator TCP Slave Simulator

הורד סימולטור Modbus Slave מ https://www.modbusdriver.com/diagslave.html. לאחר מכן פתח את הארכיון שהורדת ופרק את גרסת מערכת ההפעלה Linux.

הפעל את התוכנית מהמסוף עם ארגומנט -p:

./diagslave -p

היא יציאה שבה שרת Modbus Slave יפעל. עבור פרוטוקול Modbus זה כברירת מחדל 502, אבל אתה יכול להשתמש בפרוטוקול אחר.

ביציאות Linux מתחת ל- 1024 לא ניתן להשתמש בתוכניות המופעלות ממשתמש רגיל (לא הרשאות שורש).

זכור באיזה פורט אתה משתמש. ערך זה יהיה נחוץ מאוחר יותר.

שלב 2: הכן את המחשב שלך לחיבור למכשיר

תצטרך כמה תוכניות כדי ליצור חיבור למכשיר ולשלוח אליו קבצים.

התקן את סביבת פייתון ופיפ (אם אין לך את זה):

apt-get להתקין python3

apt-get להתקין python3-dev curl "https://bootstrap.pypa.io/get-pip.py" -o "get-pip.py" python3 get-pip.py

התקן את picocom:

apt-get להתקין picocom

תוכנית זו נחוצה כדי להתחבר להתקן ולבצע בו פקודות. התקן mpfshell:

pip התקן mpfshell

תוכנית זו מאפשרת לך לשלוח קבצים למכשיר.

אתה יכול גם להתקין אותו ממקורות. עיין בדף זה:

שלב 3: הכינו את המכשיר והתחברו אליו

כדי לחבר את מכשיר Moduino או Pycom למחשב PC אתה צריך יציאת RS-232/RS-485 או ממיר. בדוק את גרסת המכשיר שלך (באיזה סוג יציאה הוא משתמש) ומצא יציאה או ממיר מתאימים.

1. חבר את המכשיר למחשב
2. לאחר מכן חבר אליו ספק כוח

חבר את המכשיר למחשב ולאחר מכן חבר אליו את ספק הכוח. תוכל גם לחבר כבל אתרנט ל- Moduino ESP32 (אם יש לו את היציאה הזו).

החיבור צריך להיות כמו בתמונות למעלה

מצא נתיב ליציאה, המשמש לחיבור התקנים. זה יכול להיות למשל: /dev /ttyS1, /dev /ttyUSB0.

עבור ממירים usb, הנתיב יכיל מילת USB.

אתה יכול להתחבר למכשיר באמצעות תוכנית picocom:

picocom /dev /ttyUSB0 -b 115200

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

Moduino ESP32: ראה כאן

Moduino Pycom: ראה כאן

שלב 4: העלה את ספריית האב של Modbus

github.com/pycom/pycom-modbus/ כדי לתקשר עם Modbus Slave אתה צריך ספרייה מתאימה. ספריות עבור Pycom אינן תואמות את Moduino. בדוק הוראות התואמות את המכשיר שלך.

סגור את picocom לפני שליחת קבצים: הקש Ctrl+A ולאחר מכן על מקשי Ctrl+X.

ספריית uModBus עבור Moduino ESP32 מבוססת על ספריית pycom-modbus עבור Moduino Pycom. הוא שונה לעבודה על מכשיר ESP32 רגיל. יש לו גם שיטות סגירה נוספות () לשיעורי מחברים.

1) מודוינו ESP32

הורד את הספרייה מ- https://github.com/techbase123/micropython-modbus. פרק את הארכיון ושלח את כל 4 הקבצים למכשיר Moduino.

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

התחבר למכשיר על ידי ביצוע: THIS

ttyUSB0 הוא שם של יציאה טורית שבה המכשיר מחובר.

שנה את הספרייה ל- /flash /lib באמצעות הפקודה:

cd /flash /lib

שים את כל הקבצים עם פקודות:

לשים uModBusConst.py

לשים uModBusFunctions.py לשים uModBusTCP.py לשים uModBusSerial.py

דוגמא

לאחר מכן צא מהקונסולה עם פקודת יציאה והפעל מחדש את המכשיר באמצעות לחצן איפוס.

2) מודוינו פיקום

הורד את הספרייה מ- https://github.com/pycom/pycom-modbus/. פרק את הארכיון ושלח את התוכן של ספריית uModbus למכשיר. השתמש ב- mpfshell כדי להעלות אותם. הפעל תוכנית זו בספרייה עם הקבצים האלה.

התחבר למכשיר על ידי ביצוע:

פתוח ttyUSB0

ttyUSB0 הוא שם של יציאה טורית שבה המכשיר מחובר.

שנה את הספרייה ל- /flash /lib, צור ספריית uModbus והזן אותה באמצעות פקודות:

cd /flash /libmd uModbus cd uModbus

שים את כל הקבצים עם פקודות:

לשים const.py

לשים functions.py לשים tcp.py לשים serial.py

לאחר מכן צא מהקונסולה עם פקודת יציאה והפעל מחדש את המכשיר באמצעות לחצן איפוס.

דוגמא

שלב 5: התחבר לרשת

הפקודות ליצירת קשר שונות בין מודוינו לפייקום.

התחבר למכשיר באמצעות picocom כדי לבצע פקודות מתאימות. אתה יכול לחבר את מכשיר Moduino לרשת באמצעות חוט או אלחוטי. הדוגמאות הבאות מניחות שלרשת שלך יש שרת DHCP עובד.

במקרה אחר, המכשיר לא יקבל כתובת IP. תמיכה ב- Wi -Fi זמינה בכל Moduino. יציאת אתרנט היא אופציה ולא לכל המכשירים יש אותה.

1) מודוינו ESP32

מתחבר ל- WiFi

בצע את הפקודות הבאות במכשיר:

מאת netWiFi יבוא netWiFiwifi = netWiFi (netWiFi. WIFI_STA, 'ESSID', 'PASS') wifi.start ()

החלף את ESSID בשם רשת ה- WiFi שלך ו- PASS עם הסיסמה שלה.

כעבור זמן מה לאחר ביצוע ההתחלה () אתה אמור לקבל כתובת IP שהוקצתה למכשיר שלך.

חיבור לרשת אתרנט

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

לאחר מכן בצע את הפקודות הבאות:

מאת netETH יבוא netETHeth = netETH () eth.start ()

כעבור זמן מה לאחר ביצוע ההתחלה () אתה אמור לקבל כתובת IP שהוקצתה למכשיר שלך.

2) מודוינו פיקום

התחבר ל- WiFi

בצע את הפקודות הבאות במכשיר:

מיבוא רשת WLANwlan = WLAN (mode = WLAN. STA) רשתות = wlan.scan () עבור רשת ברשתות: אם net.ssid == 'ESSID': הדפס ('נמצאה רשת!') wlan.connect (net.ssid, auth = (net.sec, 'PASS'), פסק זמן = 5000) בזמן שאינו wlan.isconnected (): machine.idle () print ('חיבור WLAN הצליח!') שבירה

החלף את ESSID בשם רשת ה- WiFi שלך ו- PASS עם הסיסמה שלה.

שלב 6: אתחל את התקשורת עם Modbus Slave

ספריות Modbus Master דומות לשני המכשירים

הם משתנים באתחול.

1) אתחל uModBus ב- Moduino ESP32

לבצע:

מאת uModBusTCP ייבא uModBusTCP כ- TCP

2) אתחל uModBus ב- Pycom

לבצע:

מ- uModbus.tcp ייבוא TCP

חיבור פתוח

לאחר מכן פתח חיבור עם:

modbus = TCP ('IP', PORT, 60)

איפה:

• IP - כתובת IP של המחשב שלך עם סימולטור Modbus Slave
• PORT - נמל Modbus Slave
• 60 הוא פסק זמן

אם מתרחשת השגיאה הבאה במהלך ביצוע פקודות קריאה/כתיבה: דוגמה

לבצע:

עבור מודוינו ESP32:

modbus.close ()

עבור Moduino Pycom:

modbus._sock.close ()

ולאחר מכן צור מחדש את החיבור:

modbus = TCP ('IP', PORT, 60)

חשוב לסגור שקע לפני יצירת חיבור מחדש. למכשיר יש כמות מוגבלת של חיבור שקע זמין.

שלב 7: קריאה וכתיבה של רישומים

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

לספריית uModBus יש שיטה לכל פונקציה:

1. קריאה_סלילים
2. read_discrete_inputs
3. register_holding_registers
4. register_input_registers
5. סליל_יחיד_סינגל
6. רשום_יחיד_רשם

ראשית, אפשר לכתוב כמה ערכים.

1) כתוב סלילים (פונקציה: 5)

כתוב ערך אחד ל -200 רישום מעבד 1:

modbus.write_single_coil (1, 200, 0xFF00)

הטענה הראשונה היא עבור מזהה העבדים, במקרה שלנו 1.

השני הוא מספר הרשמה והערך הוא ערך. עבור 1 אתה צריך לשים 0xFF00 כאן. כתוב 0 עד 201 הרשמה מעבד 1:

modbus.write_single_coil (1, 201, 0)

שיטה זו מאפשרת לכתוב רק ערכים בוליאניים: 0 או 1.

2) כתוב רשמים (פונקציה: 6)

כעת כתוב כמה ערכים שלמים למספר רגידים.

כתוב ערך 111 חתום כדי לרשום 100 מעבד 1:

modbus.write_single_register (1, 100, 111, True)

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

כתוב ערך חתום -457 לרשום 101 מעבד 1:

modbus.write_single_register (1, 101, -457)

כתוב ערך לא חתום 50 ל -100 רישום מעבד 3:

modbus.write_single_register (3, 100, 50, False)

שיטה זו מאפשרת כתיבת ערכי מספר שלם לרשם בודד.

רישום יחיד יכול להכיל ערכי 16 סיביות.

השיטה מחזירה True הוא ערך הקלט חוקי ושקר אם לא. הערך נכתב גם אם אינו חוקי (גדול מדי לרישום)

3) קרא סלילים/כניסות נפרדות

עכשיו אפשר לקרוא ערכים בוליאניים כתובים. כדי לקרוא רישום עם פונקציה 1 סליל קריאה, בצע:

modbus.read_coils (slaveId, register, count) [0: count]

כדי לקרוא רישום עם פונקציה 2 לקרוא קלט נפרד, בצע:

modbus.read_discrete_inputs (slaveId, register, count) [0: count]

איפה:

• slave -id - מזהה של עבד וירטואלי (סימולטור העבדים מקבל את כל המזהים התקפים)
• הרשמה - מספר רישום לקריאה
• ספירה - כמות הרשמים לקריאה (שים את הכמות הרצויה בשני המקומות)

שיטות אלה מחזירות מערך עם ערכים בוליאניים. כל ערך מתאים לכל רישום.

יש צורך בשבר: [0: count], מכיוון ששיטה זו מחזירה יותר ערכים מאשר ספירה. הוא מחזיר תמיד את כמות הערכים הניתנת לחלוקה ב- 8. ערכים נוספים הם שקר ואינם תואמים לאף רישום.

קרא את הערכים הבולאניים שלנו בשתי השיטות:

modbus.read_coils (1, 200, 2) [0: 2] modbus.read_discrete_inputs (1, 200, 2) [0: 2]

התוצאה תהיה כזו: דוגמה

אמת מתייחס לערך אחד, שקר ל- 0.

4) קרא רישומים

כעת קרא ערכים מרשמים שנכתבו עם פונקציה 6.

כדי לקרוא רשמים עם פונקציה 3 לקרוא אוגרי החזקה, בצע:

modbus.read_holding_registers (slaveId, register, count, signed = True)

לקריאת רשמים עם פונקציית 4 אוגרי קלט קריאה, בצע:

modbus.read_input_registers (slaveId, register, count, signed = True)

איפה:

• slave -id - מזהה של עבד וירטואלי
• הרשמה - מספר רישום לקריאה
• count - כמות הרשמים לקריאה
• חתום - מציין אם יש להתייחס לערכי קריאה כמספרים חתומים או לא. מצב ברירת מחדל: נכון

ערך ההחזרה הוא זוג עם כמות הרשמים הרצויה.

קרא רישומים שהוגדרו בנקודה הקודמת:

modbus.read_holding_registers (1, 100, 2, True) modbus.read_input_registers (1, 100, 2, True) modbus.read_holding_registers (3, 100, 1, False) modbus.read_input_registers (3, 100, 1, False)

התוצאות צריכות להיראות בצילום מסך זה: דוגמה

בשיעור הבא תלמד כיצד ליצור Modbus RTU Master במכשיר המאפשר ESP32.