תקשורת אלחוטית של LoRa 3 עד 8 קילומטרים עם E32 בעלות נמוכה (sx1278/sx1276) עבור Arduino, Esp8266 או Esp32: 15 שלבים

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

אני יוצר ספרייה לניהול EBYTE E32 המבוססת על סדרת Semtech של מכשירי LoRa, מכשיר חזק מאוד, פשוט וזול.

אתה יכול למצוא גרסה של 3 ק"מ כאן, גירסה של 8 ק"מ כאן

הם יכולים לעבוד על מרחק של 3000m עד 8000m, ויש להם הרבה תכונות ופרמטרים. אז אני יוצר את הספרייה הזו כדי לפשט את השימוש.

זהו פתרון לאחזור נתונים מחיישנים מטרופולינים או לשליטה במזל ט.

אספקה

ארדואינו UNO

Wemos D1 מיני

גרסת LoRa E32 TTL 100 3Km

גרסת LoRa E32 TTL 1W 8Km

שלב 1: ספרייה

תוכל למצוא את הספרייה שלי כאן.

להוריד.

לחץ על הלחצן DOWNLOADS בפינה השמאלית העליונה, שנה את שם התיקיה הלא דחוסה LoRa_E32.

בדוק שהתיקייה LoRa_E32 מכילה LoRa_E32.cpp ו- LoRa_E32.h.

מקם את תיקיית הספרייה LoRa_E32 שלך / ספריות / תיקייה. ייתכן שיהיה עליך ליצור את תיקיית המשנה של הספריות אם זו הספרייה הראשונה שלך.

הפעל מחדש את IDE.

שלב 2: Pinout

כפי שאתה יכול לראות אתה יכול להגדיר מצבים שונים באמצעות סיכות M0 ו- M1.

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

שלב 3: סיכת AUX

כפי שכבר אמרתי לא חשוב לחבר את כל הסיכה לפלט של המיקרו -בקר, אתה יכול לשים את סיכות M0 ו- M1 ל- HIGH או LOW כדי לקבל תצורה מבוקשת, ואם לא תחבר את AUX הספרייה תקבע עיכוב סביר כדי להיות בטוח שהפעולה הושלמה.

סיכת AUX

בעת העברת נתונים ניתן להשתמש כדי להעיר MCU חיצוני ולהחזיר HIGH בסיום העברת הנתונים.

בעת קבלת AUX הולך נמוך וחוזר גבוה כאשר המאגר ריק.

הוא משמש גם לבדיקה עצמית כדי לשחזר את הפעולה הרגילה (בהדלקה ובמצב שינה/תכנית).

שלב 4: סכמה מחוברת לחלוטין Esp8266

סכימת החיבור esp8266 פשוטה יותר מכיוון שהיא פועלת באותו מתח של תקשורת לוגית (3.3v).

חשוב להוסיף נגד משיכה (4, 7 קאוהם) כדי לקבל יציבות טובה.

שלב 5: סכמה מחוברת לחלוטין Arduino

מתח העבודה של ארדואינו הוא 5 וולט, לכן עלינו להוסיף מחלק מתח על סיכת RX M0 ו- M1 של מודול LoRa כדי למנוע נזק, תוכל לקבל מידע נוסף כאן מחלק מתח: מחשבון ויישום.

אתה יכול להשתמש בנגד 2Kohm ל- GND ו- 1Kohm מהאות מאשר להרכיב אותו ב- RX.

שלב 6: ספרייה: קונסטרוקטור

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

LoRa_E32 (בתים rxPin, בת txPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

LoRa_E32 (בתים rxPin, בת txPin, בת auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600); LoRa_E32 (בתים rxPin, בת txPin, בת auxPin, בת m0Pin, בת m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

הסט הראשון של הקונסטרוקטור יוצר כדי להאציל את הניהול של סיכות סיכות אחרות לספרייה.

rxPin ו- txPin הוא הסיכה לחיבור ל- UART והם חובה.

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

m0pin ו- m1Pin הם הסיכות לשינוי מצב הפעולה (עיין בטבלה העליונה), אני חושב שהסיכות האלה ב"ייצור "הולכות להתחבר ישירות HIGH או LOW, אך לצורך בדיקה הן מועילות בניהול הספרייה.

bpsRate הוא שיעור הקצב של SoftwareSerial בדרך כלל הוא 9600 (קצב השידור היחיד במצב תוכניות/שינה)

דוגמא פשוטה היא

#כלול "LoRa_E32.h" LoRa_E32 e32ttl100 (2, 3); // RX, TX // LoRa_E32 e32ttl100 (2, 3, 5, 6, 7); // RX, TX

אנו יכולים להשתמש ישירות ב- SoftwareSerial עם בונה אחר

LoRa_E32 (HardwareSerial* סדרתי, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

LoRa_E32 (HardwareSerial* סדרתי, atePin byte, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

LoRa_E32 (HardwareSerial* טורי, בת auxPin, בת m0Pin, בת m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

הדוגמא העליונה עם הקונסטרוקטור הזה יכולה להיות כך.

#include #include "LoRa_E32.h"

SoftwareSerial mySerial (2, 3); // RX, TX

LoRa_E32 e32ttl100 (& mySerial);

// LoRa_E32 e32ttl100 (& mySerial, 5, 7, 6);

הסט של הקונסטרוקטור הוא לאפשר שימוש ב- HardwareSerial במקום ב- SoftwareSerial.

LoRa_E32 (SoftwareSerial* סדרתי, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

LoRa_E32 (SoftwareSerial* סדרתי, atePin byte, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

LoRa_E32 (SoftwareSerial* טורי, בת auxPin, בת m0Pin, בת m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

שלב 7: התחל

הפקודה start משמשת להפעלה סידורי וסיכות במצב קלט ופלט.

החלל ריק ();

בביצוע הוא

// הפעל את כל הסיכות ו- UART

e32ttl100.begin ();

שלב 8: שיטת תצורה ומידע

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

ResponseStructContainer getConfiguration ();

ResponseStatus setConfiguration (תצורה של תצורה, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE);

ResponseStructContainer getModuleInformation ();

void printParameters (תצורת תצורת struct);

ResponseStatus resetModule ();

שלב 9: מיכל תגובה

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

ResponseStatus

זהו מיכל סטטוס ויש לו 2 נקודת כניסה פשוטה, בעזרתו תוכל לקבל את קוד המצב ותיאור קוד הסטטוס

Serial.println (c.getResponseDescription ()); // תיאור הקוד

Serial.println (קוד קוד); // 1 אם הצלחה

הקוד הוא

הצלחה = 1, ERR_UNKNOWN, ERR_NOT_SUPPORT, ERR_NOT_IMPLEMENT, ERR_NOT_INITIAL, ERR_INVALID_PARAM, ERR_DATA_SIZE_NOT_MATCH, ERR_BUF_TOO_SMALL, ERR_TIMEOUT, ERR_HARDWARE, ERR_HEAD_NOT_RECOGNIZED

תגובה מכיל

מיכל זה נוצר לניהול תגובת מחרוזת ובעל 2 נקודת כניסה.

הנתונים עם המחרוזת החזירו מההודעה והסטטוס מופע של RepsonseStatus.

ResponseContainer rs = e32ttl.receiveMessage ();

הודעת מחרוזת = rs.data;

Serial.println (rs.status.getResponseDescription ());

Serial.println (הודעה);

ResponseStructContainer

זהו המיכל ה"מורכב "יותר, אני משתמש בו לניהול מבנה, יש לו את אותה נקודת כניסה של ResponseContainer אך הנתונים מהווים מצביע ריק לניהול מבנה מורכב.

ResponseStructContainer c;

c = e32ttl100.getConfiguration (); // חשוב לקבל מצביע תצורה לפני כל פעולה אחרת

תצורה של תצורה = *(תצורה *) c.data;

Serial.println (c.status.getResponseDescription ());

Serial.println (c.status.code);

getConfiguration ו- setConfiguration

השיטה הראשונה היא getConfiguration, תוכל להשתמש בה כדי לאחזר את כל הנתונים המאוחסנים במכשיר.

ResponseStructContainer getConfiguration ();

הנה דוגמא לשימוש.

ResponseStructContainer c;

c = e32ttl100.getConfiguration (); // חשוב לקבל מצביע תצורה לפני כל פעולה אחרת

תצורה של תצורה = *(תצורה *) c.data;

Serial.println (c.status.getResponseDescription ());

Serial.println (c.status.code);

Serial.println (configuration. SPED.getUARTBaudRate ());

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

config. ADDL = 0x0; // חלק ראשון בתצורת כתובת. ADDH = 0x1; // חלק שני של תצורת כתובת. CHAN = 0x19; // תצורת ערוץ. OPTION.fec = FEC_0_OFF; // תצורה של מתג תיקון שגיאות קדימה. OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION; // תצורת מצב שידור. OPTION.ioDriveMode = IO_D_MODE_PUSH_PULLS_PULL_UPS; // תצורת ניהול משיכה. OPTION.transmissionPower = POWER_17; // תצורת כוח שידור dBm. OPTION.wirelessWakeupTime = WAKE_UP_1250; // זמן המתנה לתצורת השכמה. SPED.airDataRate = AIR_DATA_RATE_011_48; // תצורת קצב נתוני אוויר. SPED.uartBaudRate = UART_BPS_115200; // תצורת קצב שידור תקשורת. SPED.uartParity = MODE_00_8N1; // קצת זוגיות

יש לך את הפונקציה המקבילה לכל המאפיין כדי לקבל את כל התיאור:

Serial.print (F ("צ'אן:")); Serial.print (configuration. CHAN, DEC); Serial.print (" ->"); Serial.println (configuration.getChannelDescription ()); Serial.println (F ("")); Serial.print (F ("SpeedParityBit:")); Serial.print (configuration. SPED.uartParity, BIN); Serial.print (" ->"); Serial.println (configuration. SPED.getUARTParityDescription ()); Serial.print (F ("SpeedUARTDatte:")); Serial.print (configuration. SPED.uartBaudRate, BIN); Serial.print (" ->"); Serial.println (configuration. SPED.getUARTBaudRate ()); Serial.print (F ("SpeedAirDataRate:")); Serial.print (configuration. SPED.airDataRate, BIN); Serial.print (" ->"); Serial.println (configuration. SPED.getAirDataRate ()); Serial.print (F ("OptionTrans:")); Serial.print (configuration. OPTION.fixedTransmission, BIN); Serial.print (" ->"); Serial.println (configuration. OPTION.getFixedTransmissionDescription ()); Serial.print (F ("OptionPullup:")); Serial.print (configuration. OPTION.ioDriveMode, BIN); Serial.print (" ->"); Serial.println (configuration. OPTION.getIODroveModeDescription ()); Serial.print (F ("OptionWakeup:")); Serial.print (configuration. OPTION.wirelessWakeupTime, BIN); Serial.print (" ->"); Serial.println (configuration. OPTION.getWirelessWakeUPTimeDescription ()); Serial.print (F ("OptionFEC:")); Serial.print (configuration. OPTION.fec, BIN); Serial.print (" ->"); Serial.println (configuration. OPTION.getFECDescription ()); Serial.print (F ("OptionPower:")); Serial.print (configuration. OPTION.transmissionPower, BIN); Serial.print (" ->"); Serial.println (configuration. OPTION.getTransmissionPowerDescription ());

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

ResponseStatus setConfiguration (תצורה של תצורה, PROGRAM_COMMAND saveType = WRITE_CFG_PWR_DWN_LOSE);

התצורה היא ההצגה הקודמת של strucutre, שמור לך TypeType כדי לבחור אם השינוי הופך לצמיתות רק למפגש הנוכחי.

ResponseStructContainer c; c = e32ttl100.getConfiguration (); // חשוב לקבל מצביע תצורה לפני כל הפעולות האחרות תצורת תצורה = *(תצורה *) c.data; Serial.println (c.status.getResponseDescription ()); Serial.println (c.status.code); printParameters (תצורה); config. ADDL = 0x0; konfiguration. ADDH = 0x1; תצורה. CHAN = 0x19; config. OPTION.fec = FEC_0_OFF; configuration. OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION; konfiguration. OPTION.ioDriveMode = IO_D_MODE_PUSH_PULLS_PULL_UPS; konfiguration. OPTION.transmissionPower = POWER_17; konfiguration. OPTION.wirelessWakeupTime = WAKE_UP_1250; configuration. SPED.airDataRate = AIR_DATA_RATE_011_48; configuration. SPED.uartBaudRate = UART_BPS_115200; configuration. SPED.uartParity = MODE_00_8N1; // הגדרת התצורה השתנתה והגדרתה לא להחזיק את התצורה ResponseStatus rs = e32ttl100.setConfiguration (תצורה, WRITE_CFG_PWR_DWN_LOSE); Serial.println (rs.getResponseDescription ()); Serial.println (rs.code); printParameters (תצורה);

הפרמטרים כולם מנוהלים כקבועים:

שלב 10: אפשרות תצורה בסיסית

שלב 11: שלח הודעת קבלה

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

int זמין ();

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

שלב 12: מצב שידור רגיל

מצב שידור רגיל/שקוף משמש לשליחת הודעות לכל המכשיר בעל אותה כתובת וערוץ.

יש הרבה שיטות לשלוח/לקבל הודעה, אנחנו הולכים להסביר בפירוט:

ResponseStatus sendMessage (הודעת מחרוזת קבועה);

ResponseContainer receiveMessage ();

השיטה הראשונה היא sendMessage ומשמשת לשליחת מחרוזת למכשיר במצב רגיל.

ResponseStatus rs = e32ttl.sendMessage ("Prova"); Serial.println (rs.getResponseDescription ());

המכשיר השני פשוט עושה על הלולאה

if (e32ttl.available ()> 1) {ResponseContainer rs = e32ttl.receiveMessage (); הודעת מחרוזת = rs.data; // קודם כל לקבל את הנתונים Serial.println (rs.status.getResponseDescription ()); Serial.println (הודעה); }

שלב 13: נהל את המבנה

אם אתה רוצה לשלוח סטרוקטור מורכב אתה יכול להשתמש בשיטה זו

ResponseStatus sendMessage (const void *message, const uint8_t size); ResponseStructContainer receiveMessage (const uint8_t size);

הוא משמש לשליחת strucutre, למשל:

struct Messaggione {סוג char [5]; הודעת צ'ארה [8]; בול מיטיקו; }; struct Messaggione messaggione = {"TEMP", "Peple", true}; ResponseStatus rs = e32ttl.sendMessage (& messaggione, sizeof (Messaggione)); Serial.println (rs.getResponseDescription ());

והצד השני תוכל לקבל את ההודעה כך

ResponseStructContainer rsc = e32ttl.receiveMessage (sizeof (Messaggione)); struct Messaggione messaggione = *(Messaggione *) rsc.data; Serial.println (messaggione.message); Serial.println (messaggione.mitico);

קראו את המבנה החלקי

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

ResponseContainer receiveInitialMessage (גודל const uint8_t);

אני יוצר את זה כדי לקבל מחרוזת עם סוג או אחר כדי לזהות את strucuture לטעון.

struct Messaggione {// חלקית strucutre ללא הודעת טכניק [8]; בול מיטיקו; }; סוג חרוסת [5]; // חלק ראשון של המבנה ResponseContainer rs = e32ttl.receiveInitialMessage (sizeof (type)); // הכנס מחרוזת למערך char (אין צורך) memcpy (type, rs.data.c_str (), sizeof (type)); Serial.println ("קרא סוג סוג:"); Serial.println (rs.status.getResponseDescription ()); Serial.println (סוג); // קרא את שאר המבנה ResponseStructContainer rsc = e32ttl.receiveMessage (sizeof (Messaggione)); struct Messaggione messaggione = *(Messaggione *) rsc.data;

שלב 14: מצב קבוע במקום מצב רגיל

באותו אופן אני יוצר מערך שיטות לשימוש עם שידור קבוע

שידור קבוע

עליך לשנות רק את שיטת השליחה, מכיוון שמכשיר היעד אינו מקבל את ההקדמה עם כתובת ומצב ערוץ quando settato il קבוע.

אז להודעת מחרוזת יש לך

ResponseStatus sendFixedMessage (byte ADDL, byte ADDH, byte CHAN, const String message); ResponseStatus sendBroadcastFixedMessage (בתים CHAN, הודעת מחרוזת const);

ולמבנה שיש לך

ResponseStatus sendFixedMessage (byte ADDL, byte ADDH, byte CHAN, const void *message, const uint8_t size); ResponseStatus sendBroadcastFixedMessage (byte CHAN, const void *message, const uint8_t size);

הנה דוגמא פשוטה

ResponseStatus rs = e32ttl.sendFixedMessage (0, 0, 0x17, & messaggione, sizeof (Messaggione)); // ResponseStatus rs = e32ttl.sendFixedMessage (0, 0, 0x17, "Ciao");

לשידור קבוע יש תרחישים נוספים

אם אתה שולח להתקן ספציפי (תרחישים שני שידור קבוע) עליך להוסיף ADDL, ADDH ו- CHAN כדי לזהות אותו ישירות.

ResponseStatus rs = e32ttl.sendFixedMessage (2, 2, 0x17, "הודעה למכשיר");

אם אתה רוצה לשלוח הודעה לכל המכשיר בערוץ שצוין, תוכל להשתמש בשיטה זו.

ResponseStatus rs = e32ttl.sendBroadcastFixedMessage (0x17, "הודעה למכשירי ערוץ");

אם אתה רוצה לקבל את כל הודעות השידור ברשת, עליך להגדיר את ה- ADDH וה- ADDL שלך עם BROADCAST_ADDRESS.

ResponseStructContainer c; c = e32ttl100.getConfiguration (); // חשוב לקבל מצביע תצורה לפני כל הפעולות האחרות תצורת תצורה = *(תצורה *) c.data; Serial.println (c.status.getResponseDescription ()); Serial.println (c.status.code); printParameters (תצורה); config. ADDL = BROADCAST_ADDRESS; konfiguration. ADDH = BROADCAST_ADDRESS; // הגדרת התצורה השתנתה והגדרתה לא להחזיק את התצורה ResponseStatus rs = e32ttl100.setConfiguration (תצורה, WRITE_CFG_PWR_DWN_LOSE); Serial.println (rs.getResponseDescription ()); Serial.println (rs.code); printParameters (תצורה);

שלב 15: תודה

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

1. מכשיר LoRa E32 עבור Arduino, esp32 או esp8266: הגדרות ושימוש בסיסי
2. מכשיר LoRa E32 עבור Arduino, esp32 או esp8266: ספרייה
3. מכשיר LoRa E32 עבור Arduino, esp32 או esp8266: תצורה
4. מכשיר LoRa E32 עבור Arduino, esp32 או esp8266: שידור קבוע
5. מכשיר LoRa E32 עבור Arduino, esp32 או esp8266: חיסכון בחשמל ושליחת נתונים מובנים