LoRa 3 კმ -დან 8 კმ -მდე უკაბელო კომუნიკაცია დაბალი ღირებულებით E32 (sx1278/sx1276) მოწყობილობა Arduino- სთვის, Esp8266 ან Esp32: 15 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:15

მე ვქმნი ბიბლიოთეკას EBYTE E32- ის მართვისთვის LoRa მოწყობილობის Semtech სერიის საფუძველზე, ძალიან ძლიერი, მარტივი და იაფი მოწყობილობა.

თქვენ შეგიძლიათ ნახოთ 3 კმ ვერსია აქ, 8 კმ ვერსია აქ

მათ შეუძლიათ იმუშაონ 3000 მ -დან 8000 მ -მდე მანძილზე და მათ აქვთ მრავალი მახასიათებელი და პარამეტრი. ასე რომ, მე ვქმნი ამ ბიბლიოთეკას გამოყენების გასაადვილებლად.

ეს არის გამოსავალი მეტროპოლიტენის სენსორების მონაცემების მოსაპოვებლად ან თვითმფრინავის გასაკონტროლებლად.

მარაგები

Arduino UNO

Wemos D1 მინი

LoRa E32 TTL 100 3 კმ ვერსია

LoRa E32 TTL 1W 8 კმ ვერსია

ნაბიჯი 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 მიდის დაბალ დონეზე და დაბრუნდება HIGH როდესაც ბუფერი ცარიელია.

იგი ასევე გამოიყენება თვით შემოწმებისთვის ნორმალური მუშაობის აღდგენისათვის (ჩართვისა და ძილის/პროგრამის რეჟიმში).

ნაბიჯი 4: სრულად დაკავშირებული სქემა Esp8266

esp8266 კავშირის სქემა უფრო მარტივია, რადგან ის მუშაობს ლოგიკური კომუნიკაციის იმავე ძაბვაზე (3.3v).

კარგი სტაბილურობის მისაღწევად მნიშვნელოვანია დაამატოთ გამწევი რეზისტორი (4, 7Kohm).

ნაბიჯი 5: სრულად დაკავშირებული სქემა Arduino

არდუინოს სამუშაო ძაბვა არის 5 ვ, ამიტომ ჩვენ უნდა დავამატოთ ძაბვის გამყოფი LoRa მოდულის RX პინ M0 და M1 დაზიანების თავიდან ასაცილებლად, მეტი ინფორმაციის მიღება შეგიძლიათ აქ ძაბვის გამყოფი: კალკულატორი და პროგრამა.

თქვენ შეგიძლიათ გამოიყენოთ 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 არის ქინძისთავები ოპერაციის რეჟიმის შესაცვლელად (იხ. ცხრილის ზედა ნაწილი), მე ვფიქრობ, რომ "წარმოების" ეს ქინძისთავები პირდაპირ პირდაპირ ან დაბალს დაუკავშირდება, მაგრამ შესამოწმებლად ისინი ბიბლიოთეკის მიერ გამოსადეგია.

bpsRate არის პროგრამული უზრუნველყოფის ბუდარატი სერიული ჩვეულებრივ არის 9600 (პროგრამის/ძილის რეჟიმში ერთადერთი baud მაჩვენებელი)

მარტივი მაგალითია

#მოიცავს "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* სერიული, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

LoRa_E32 (HardwareSerial* სერიული, byte auxPin, byte m0Pin, byte m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

მაგალითი ზედა ამ კონსტრუქტორი შეიძლება იყოს ასე.

#მოიცავს #მოიცავს "LoRa_E32.h"

პროგრამული უზრუნველყოფა სერიული mySerial (2, 3); // RX, TX

LoRa_E32 e32ttl100 (& mySerial);

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

კონსტრუქტორის ბოლო კომპლექტი არის ნება დართოს გამოიყენოს HardwareSerial პროგრამული უზრუნველყოფის ნაცვლად.

LoRa_E32 (სერიული პროგრამული უზრუნველყოფა*, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

LoRa_E32 (SoftwareSerial* სერიული, byte auxPin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

LoRa_E32 (პროგრამული უზრუნველყოფის სერიული* სერიული, ბაიტი auxPin, ბაიტი m0Pin, ბაიტი m1Pin, UART_BPS_RATE bpsRate = UART_BPS_RATE_9600);

ნაბიჯი 7: დასაწყისი

დაწყება ბრძანება გამოიყენება სერიალის დასაწყებად და ქინძისთავების შესასვლელ და გამომავალ რეჟიმში.

ბათილად იწყება ();

აღსრულებაში არის

// დაიწყეთ ყველა ქინძისთავები და UART

e32ttl100. დაწყება ();

ნაბიჯი 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 (c.code); // 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

ResponseContainer

ეს კონტეინერი შექმნილია სიმებიანი პასუხის მართვისთვის და აქვს 2 შესვლის წერტილი.

სტრიქონის მონაცემები დაბრუნდა შეტყობინებიდან და სტატუსიდან RepsonseStatus- ის მაგალითი.

ResponseContainer rs = e32ttl.receiveMessage ();

სიმებიანი შეტყობინება = rs.data;

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

Serial.println (შეტყობინება);

ResponseStructContainer

ეს არის უფრო "რთული" კონტეინერი, მე მას ვიყენებ სტრუქტურის მართვისთვის, მას აქვს იგივე შესვლის წერტილი ResponseContainer, მაგრამ მონაცემები არის ბათილი მაჩვენებელი რთული სტრუქტურის მართვისთვის.

ResponseStructContainer გ;

c = e32ttl100.getConfiguration (); // მნიშვნელოვანია ყველა სხვა ოპერაციამდე კონფიგურაციის მაჩვენებლის მიღება

კონფიგურაციის კონფიგურაცია = *(კონფიგურაცია *) c.data;

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

Serial.println (c.status.code);

getConfiguration და setConfiguration

პირველი მეთოდი არის getConfiguration, შეგიძლიათ გამოიყენოთ იგი მოწყობილობაზე შენახული ყველა მონაცემის აღსადგენად.

ResponseStructContainer getConfiguration ();

აქ არის გამოყენების მაგალითი.

ResponseStructContainer გ;

c = e32ttl100.getConfiguration (); // მნიშვნელოვანია ყველა სხვა ოპერაციამდე კონფიგურაციის მაჩვენებლის მიღება

კონფიგურაციის კონფიგურაცია = *(კონფიგურაცია *) c.data;

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

Serial.println (c.status.code);

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

კონფიგურაციის სტრუქტურა შეიცავს პარამეტრების ყველა მონაცემს და მე ვამატებ რიგ ფუნქციებს, რომ მივიღო ერთიანი მონაცემების ყველა აღწერა.

კონფიგურაცია. ADDL = 0x0; // მისამართის კონფიგურაციის პირველი ნაწილი. ADDH = 0x1; // მისამართის კონფიგურაციის მეორე ნაწილი. CHAN = 0x19; // არხის კონფიგურაცია. OPTION.fec = FEC_0_OFF; // შეცდომის გამოსწორების გადამრთველის გადამისამართება configuration. 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; // კომუნიკაცია baud rate configuration. SPED.uartParity = MODE_00_8N1; // პარიტეტული ბიტი

თქვენ გაქვთ ექვივალენტი ფუნქცია ყველა ატრიბუტისთვის, რომ მიიღოთ ყველა აღწერა:

Serial.print (F ("ჩან:")); Serial.print (კონფიგურაცია. 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);

კონფიგურაცია არის უპირველეს ყოვლისა ნაჩვენები, saveType ნება დართეთ თქვენ აირჩიოთ, თუ ცვლილება სამუდამოდ გახდება მხოლოდ მიმდინარე სესიისთვის.

ResponseStructContainer c; c = e32ttl100.getConfiguration (); // მნიშვნელოვანია კონფიგურაციის მაჩვენებლის მიღება ყველა სხვა ოპერაციამდე კონფიგურაციის კონფიგურაცია = *(კონფიგურაცია *) c.data; Serial.println (c.status.getResponseDescription ()); Serial.println (c.status.code); printParameters (კონფიგურაცია); კონფიგურაცია. ADDL = 0x0; კონფიგურაცია. ADDH = 0x1; კონფიგურაცია. CHAN = 0x19; configuration. OPTION.fec = FEC_0_OFF; configuration. OPTION.fixedTransmission = FT_TRANSPARENT_TRANSMISSION; configuration. OPTION.ioDriveMode = IO_D_MODE_PUSH_PULLS_PULL_UPS; configuration. OPTION.transmissionPower = POWER_17; configuration. 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 (const სიმებიანი შეტყობინება);

ResponseContainer دریافتMessage ();

პირველი მეთოდია sendMessage და გამოიყენება სტრიქონის გასაგზავნად მოწყობილობაზე ნორმალურ რეჟიმში.

ResponseStatus rs = e32ttl.sendMessage ("პროვა"); 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 دریافتMessage (const uint8_t ზომა);

იგი გამოიყენება strucutre– ის გასაგზავნად, მაგალითად:

struct Messaggione {სიმბოლო ტიპი [5]; char შეტყობინება [8]; bool mitico; }; 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);

წაიკითხეთ ნაწილობრივი სტრუქტურა

თუ გსურთ გაგზავნის პირველი ნაწილის წაკითხვა უფრო მეტი სახის მართვისთვის, შეგიძლიათ გამოიყენოთ ეს მეთოდი.

ResponseContainer receInitialMessage (const uint8_t ზომა);

მე ვქმნი მას, რომ მივიღო სტრიქონი ტიპით ან სხვა, რათა დავადგინო სტრუქტურა ჩატვირთვისას.

struct Messaggione {// ნაწილობრივი შემსრულებელი საბეჭდი მანქანის გარეშე [8]; bool mitico; }; char ტიპი [5]; // სტრუქტურის პირველი ნაწილი ResponseContainer rs = e32ttl.receiveInitialMessage (ზომა (ტიპი)); // ჩადეთ სტრიქონი char მასივში (არ არის საჭირო) memcpy (ტიპი, rs.data.c_str (), sizeof (ტიპი)); Serial.println ("წაიკითხე ტიპი:"); Serial.println (rs.status.getResponseDescription ()); Serial.println (ტიპი); // დანარჩენი სტრუქტურის წაკითხვა ResponseStructContainer rsc = e32ttl.receiveMessage (sizeof (Messaggione)); სტრუქტურა Messaggione messaggione = *(Messaggione *) rsc.data;

ნაბიჯი 14: დაფიქსირებული რეჟიმი ჩვეულებრივი რეჟიმის ნაცვლად

ამავე დროს, მე ვქმნი მეთოდის ერთობლიობას, რომელიც გამოიყენება ფიქსირებული ტრანსმისიით

დაფიქსირდა გადაცემა

თქვენ უნდა შეცვალოთ მხოლოდ გაგზავნის მეთოდი, რადგან დანიშნულების მოწყობილობა ვერ მიიღებს პრეამბულას მისამართისა და არხის მოთხოვნების შესაბამისად დაფიქსირებული რეჟიმით.

ასე რომ სიმებიანი შეტყობინება გაქვთ

ResponseStatus sendFixedMessage (byte ADDL, byte ADDH, byte CHAN, const String message); ResponseStatus sendBroadcastFixedMessage (byte CHAN, const String message);

და სტრუქტურისთვის გაქვთ

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 (კონფიგურაცია); კონფიგურაცია. ADDL = BROADCAST_ADDRESS; კონფიგურაცია. 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: ენერგიის დაზოგვა და სტრუქტურირებული მონაცემების გაგზავნა