You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
299 lines
22 KiB
299 lines
22 KiB
# ನಿಮ್ಮ IoT ಸಾಧನವನ್ನು ಕ್ಲೌಡ್ಗೆ ಸಂಪರ್ಕಿಸಿ - Wio ಟರ್ಮಿನಲ್
|
|
|
|
ಪಾಠದ ಈ ಭಾಗದಲ್ಲಿ, ನೀವು ನಿಮ್ಮ Wio ಟರ್ಮಿನಲ್ ಅನ್ನು ನಿಮ್ಮ IoT ಹಬ್ಗಳಿಗೆ ಸಂಪರ್ಕಿಸಿ, ಟೆಲಿಮೆಟ್ರಿ ಕಳುಹಿಸುವುದು ಮತ್ತು ಆದೇಶಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದು.
|
|
|
|
## ನಿಮ್ಮ ಸಾಧನವನ್ನು IoT ಹಬ್ಗೆ ಸಂಪರ್ಕಿಸಿ
|
|
|
|
ಮುಂದಿನ ಹಂತ ನಿಮ್ಮ ಸಾಧನವನ್ನು IoT ಹಬ್ಗೆ ಸಂಪರ್ಕಿಸುವುದು.
|
|
|
|
### ಕಾರ್ಯ - IoT ಹಬ್ಗೆ ಸಂಪರ್ಕಿಸಿ
|
|
|
|
1. VS ಕೋಡ್ನಲ್ಲಿ `soil-moisture-sensor` ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ತೆರೆಯಿರಿ
|
|
|
|
1. `platformio.ini` ಫೈಲನ್ನು ತೆರೆಯಿರಿ. `knolleary/PubSubClient` ಲೈಬ್ರರಿ ಅವಲಂಬನೆಯನ್ನು ತೆಗೆದುಹಾಕಿ. ಇದು ಸಾರ್ವಜನಿಕ MQTT ಬ್ರೋಕರ್ಗೆ ಸಂಪರ್ಕಿಸಲು ಬಳಸಲಾಗುತ್ತಿದ್ದಿದ್ದು, IoT ಹಬ್ಗೆ ಸಂಪರ್ಕಿಸಲು ಅಗತ್ಯವಿಲ್ಲ.
|
|
|
|
1. ಕೆಳಗಿನ ಲೈಬ್ರರಿ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರಿಸಿ:
|
|
|
|
```ini
|
|
seeed-studio/Seeed Arduino RTC @ 2.0.0
|
|
arduino-libraries/AzureIoTHub @ 1.6.0
|
|
azure/AzureIoTUtility @ 1.6.1
|
|
azure/AzureIoTProtocol_MQTT @ 1.6.0
|
|
azure/AzureIoTProtocol_HTTP @ 1.6.0
|
|
azure/AzureIoTSocket_WiFi @ 1.0.2
|
|
```
|
|
|
|
`Seeed Arduino RTC` ಲೈಬ್ರರಿ Wio ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಇರುವ বাস্তವ-ಸಮಯ ಘಡಿಯೊಡನೆ ಸಂವಹನ ಮಾಡಲು ಕೋಡ್ ಒದಗಿಸುತ್ತದೆ, ಸಮಯವನ್ನು ಹಂಬಲಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಉಳಿದ ಲೈಬ್ರರಿಗಳು ನಿಮ್ಮ IoT ಸಾಧನಕ್ಕೆ IoT ಹಬ್ಗೆ ಸಂಪರ್ಕಿಸಲು ಅನುಮತಿಸುತ್ತವೆ.
|
|
|
|
1. `platformio.ini` ಫೈಲಿನ ಕೆಳಭಾಗಕ್ಕೆ ಕೆಳಗಿನ ಬರಹ ಸೇರಿಸಿ:
|
|
|
|
```ini
|
|
build_flags =
|
|
-DDONT_USE_UPLOADTOBLOB
|
|
```
|
|
|
|
ಇದು ಆರ್ಡಿನೋ IoT ಹಬ್ ಕೋಡ್ ಸಂकलಿಸುವಾಗ ಅಗತ್ಯವಿರುವ ಸಂಕಲಕ ಧ್ವಜವನ್ನು ಸೆಟ್ ಮಾಡುತ್ತದೆ.
|
|
|
|
1. `config.h` ಹೆಡರ್ ಫೈಲನ್ನು ತೆರೆಯಿರಿ. ಎಲ್ಲಾ MQTT ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ಸಾಧನ ಸಂಪರ್ಕ ಸರಣಿಗಾಗಿ ಕೆಳಗಿನ ಸ್ಥಿರಾಂಕವನ್ನು ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
// ಐಒಟಿ ಹಬ್ ಸೆಟ್ಟಿಂಗ್ಗಳು
|
|
const char *CONNECTION_STRING = "<connection string>";
|
|
```
|
|
|
|
`<connection string>` ಅನ್ನು ನೀವು ಮೊದಲು ನಕಲಿಸಿದ ನಿಮ್ಮ ಸಾಧನದ ಸಂಪರ್ಕ ಸರಣಿಯಿಂದ ಬದಲಾಯಿಸಿ.
|
|
|
|
1. IoT ಹಬ್ಗೆ ಸಂಪರ್ಕಿಸುವುದು ಸಮಯ-ಆಧಾರಿತ ಟೋಕನ್ ಬಳಸುತ್ತದೆ. ಇದರಿಂದ IoT ಸಾಧನವು ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು. ವಿಂಡೋಸ್, ಮಾಕ್ಒಎಸ್ ಅಥವಾ ಲಿನಕ್ಸಿನಂತಹ ಕಾರ್ಯಾಚರಣೆ ವ್ಯವಸ್ಥೆಗಳಂತೆ, ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್ಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಇಂಟರ್ನೆಟ್ ಮೂಲಕ ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುತ್ತಿಲ್ಲ. ಹಾಗಾಗಿ ನೀವು [NTP](https://wikipedia.org/wiki/Network_Time_Protocol) ಸರ್ವರ್ನಿಂದ ಪ್ರಸ್ತುತ ಸಮಯ ಪಡೆಯಲು ಕೋಡ್ ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ. ಸಮಯ ಪಡೆಯಾದ ನಂತರ, ಇದು Wio ಟರ್ಮಿನಲ್ನಲ್ಲಿನ ನಿಜ ಸಮಯ ಘಡಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದಾಗಿದೆ, ಸಾಧನ ವಿದ್ಯುತ್ ಕಳೆದುಕೊಳ್ಳದಿದ್ದರೆ, ನಂತರ ಸರಿಯಾದ ಸಮಯವನ್ನು ಕೇಳಬಹುದು. `ntp.h` ಎಂಬ ಹೊಸ ಫೈಲ್ ಅನ್ನು ಕೆಳಗಿನ ಕೋಡ್ನೊಂದಿಗೆ ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
#pragma once
|
|
|
|
#include "DateTime.h"
|
|
#include <time.h>
|
|
#include "samd/NTPClientAz.h"
|
|
#include <sys/time.h>
|
|
|
|
static void initTime()
|
|
{
|
|
WiFiUDP _udp;
|
|
time_t epochTime = (time_t)-1;
|
|
NTPClientAz ntpClient;
|
|
|
|
ntpClient.begin();
|
|
|
|
while (true)
|
|
{
|
|
epochTime = ntpClient.getEpochTime("0.pool.ntp.org");
|
|
|
|
if (epochTime == (time_t)-1)
|
|
{
|
|
Serial.println("Fetching NTP epoch time failed! Waiting 2 seconds to retry.");
|
|
delay(2000);
|
|
}
|
|
else
|
|
{
|
|
Serial.print("Fetched NTP epoch time is: ");
|
|
|
|
char buff[32];
|
|
sprintf(buff, "%.f", difftime(epochTime, (time_t)0));
|
|
Serial.println(buff);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ntpClient.end();
|
|
|
|
struct timeval tv;
|
|
tv.tv_sec = epochTime;
|
|
tv.tv_usec = 0;
|
|
|
|
settimeofday(&tv, NULL);
|
|
}
|
|
```
|
|
|
|
ಈ ಕೋಡ್ನ ವಿವರಗಳು ಈ ಪಾಠದ ವ್ಯಾಪ್ತಿಗೆ ಹೊರಗೆ. ಇದು `initTime` ಎಂದು ಕರೆಯಲ್ಪಟ್ಟ ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಅದು NTP ಸರ್ವರ್ನಿಂದ ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು Wio ಟರ್ಮಿನಲ್ನ ಘಡಿಯನ್ನು ಸೆಟ್ ಮಾಡಲು ಬಳಸುತ್ತದೆ.
|
|
|
|
1. `main.cpp` ಫೈಲನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಎಲ್ಲಾ MQTT ಕೋಡ್ನ್ನು, `PubSubClient.h` ಹೆಡರ್ ಫೈಲ್, `PubSubClient` ಚರ ಮತ್ತು ಅದರ `reconnectMQTTClient`, `createMQTTClient` ಮೆತೋಡ್ಗಳ ಘೋಷಣೆ ಮತ್ತು ಇವುಗಳಿಗೆ ಕರೆಗಳನ್ನು ತೆಗೆದುಹಾಕಿ. ಈ ಫೈಲ್ ಕೇವಲ ವೈಫೈಗೆ ಸಂಪರ್ಕಿಸಲು, ಮಣ್ಣು ಆರ್ದ್ರತೆಯನ್ನು ಪಡೆಯಲು ಮತ್ತು ಅದನ್ನು JSON ಡಾಕ್ಯುಮೆಂಟ್ನಲ್ಲಿ ತಯಾರಿಸಲು ಕೋಡ್ ಹೊಂದಿರಬೇಕು.
|
|
|
|
1. `main.cpp` ಫೈಲಿನ ಮೇಲ್ಭಾಗಕ್ಕೆ ಕೆಳಗಿನ `#include` ಸೂಚನೆಗಳನ್ನು ಸೇರಿಸಿ, ಇದು IoT ಹಬ್ ಲೈಬ್ರರಿಗಳ ಮತ್ತು ಸಮಯ ಸೆಟ್ಟಿಂಗ್ಗಾಗಿ ಹೆಡರ್ ಫೈಲ್ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:
|
|
|
|
```cpp
|
|
#include <AzureIoTHub.h>
|
|
#include <AzureIoTProtocol_MQTT.h>
|
|
#include <iothubtransportmqtt.h>
|
|
#include "ntp.h"
|
|
```
|
|
|
|
1. ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ಸೆಟ್ ಮಾಡಲು `setup` ಫಂಕ್ಷನ್ನ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನ ಕರೆ ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
initTime();
|
|
```
|
|
|
|
1. ಫೈಲಿನ ಮೇಲ್ಭಾಗದಲ್ಲಿ, ಇಂಕ್ಲೂಡ್ ಸೂಚನೆಗಳ ಕೆಳಗೆ ಈ ಚರ ಘೋಷಣೆಯನ್ನು ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
IOTHUB_DEVICE_CLIENT_LL_HANDLE _device_ll_handle;
|
|
```
|
|
|
|
ಇದು `IOTHUB_DEVICE_CLIENT_LL_HANDLE` ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ, ಇದು IoT ಹಬ್ಗೆ ಸಂಪರ್ಕ ಹ್ಯಾಂಡಲ್ ಆಗಿದೆ.
|
|
|
|
1. ಇದರ ಕೆಳಗೆ, ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
static void connectionStatusCallback(IOTHUB_CLIENT_CONNECTION_STATUS result, IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason, void *user_context)
|
|
{
|
|
if (result == IOTHUB_CLIENT_CONNECTION_AUTHENTICATED)
|
|
{
|
|
Serial.println("The device client is connected to iothub");
|
|
}
|
|
else
|
|
{
|
|
Serial.println("The device client has been disconnected");
|
|
}
|
|
}
|
|
```
|
|
|
|
ಇದು ಕೊನೆಗೆ ಸಂಪರ್ಕ ಸ್ಥಿತಿ ಬದಲಾವಣೆಗಳನ್ನು ತೋರಿಸಲು ಕರೆಮಾಡುವ ಕಾಲ್ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಆಗಿದ್ದು, ಉದಾಹರಣೆಗೆ ಸಂಪರ್ಕ ಅಥವಾ ಬಿಚ್ಚುವುದು. ಸ್ಥಿತಿಯನ್ನು ಸರಿಯು ಪೋರ್ಟ್ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.
|
|
|
|
1. ಇದರ ಕೆಳಗೆ, IoT ಹಬ್ಗೆ ಸಂಪರ್ಕಿಸಲು ಫಂಕ್ಷನ್ ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
void connectIoTHub()
|
|
{
|
|
IoTHub_Init();
|
|
|
|
_device_ll_handle = IoTHubDeviceClient_LL_CreateFromConnectionString(CONNECTION_STRING, MQTT_Protocol);
|
|
|
|
if (_device_ll_handle == NULL)
|
|
{
|
|
Serial.println("Failure creating Iothub device. Hint: Check your connection string.");
|
|
return;
|
|
}
|
|
|
|
IoTHubDeviceClient_LL_SetConnectionStatusCallback(_device_ll_handle, connectionStatusCallback, NULL);
|
|
}
|
|
```
|
|
|
|
ಈ ಕೋಡ್ IoT ಹಬ್ ಲೈಬ್ರರಿ ಕೋಡ್ ಅನ್ನು ಆರಂಭಿಸುತ್ತದೆ, ನಂತರ `config.h` ಫೈಲಿನ ಸಂಪರ್ಕ ಸರಣಿಯನ್ನು ಬಳಸಿಕೊಂಡು MQTT ಆಧಾರಿತ ಸಂಪರ್ಕವನ್ನು ರಚಿಸುತ್ತದೆ. ಸಂಪರ್ಕ ವಿಫಲವಾದರೆ, ಇದು ಸರಿಯು ಪೋರ್ಟ್ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ—ನೀವು ಇದನ್ನು ನಿಮಗೆ ದೊರಕುವ ಔಟ್ಪುಟ್ನಲ್ಲಿ ನೋಡಿದರೆ ಸಂಪರ್ಕ ಸರಣಿಯನ್ನು ಪರಿಶೀಲಿಸಿ. ಕೊನೆಗೆ ಸಂಪರ್ಕ ಸ್ಥಿತಿ ಕಾಲ್ಬ್ಯಾಕ್ ಹೊಂದಿಸಲಾಗಿದೆ.
|
|
|
|
1. ಈ ಫಂಕ್ಷನ್ ಅನ್ನು `setup` ಫಂಕ್ಷನ್ನಲ್ಲಿ `initTime` ಕರೆ ನಂತರ ಕರೆಮಾಡಿ:
|
|
|
|
```cpp
|
|
connectIoTHub();
|
|
```
|
|
|
|
1. MQTT ಕ್ಲಯಂಟ್ನಂತೆ, ಈ ಕೋಡ್ ಒಬ್ಬ ಏಕಕಾಲೀನ ತಂತೆಯಲ್ಲಿ ಚಲಿಸುತ್ತದೆ ಹಾಗಾಗಿ ಹಬ್ ಕಳುಹಿಸುವ ಮತ್ತು ಸ್ವೀಕರಿಸುವ ಸಂದೇಶಗಳನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡಲು ಸಮಯ ಬೇಕಾಗುತ್ತದೆ. ಈ ಕಾರ್ಯಕ್ಕೂ `loop` ಫಂಕ್ಷನ್ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಕೆಳಗಿನ ಬರಹ ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
IoTHubDeviceClient_LL_DoWork(_device_ll_handle);
|
|
```
|
|
|
|
1. ಈ ಕೋಡ್ ನಿರ್ಮಿಸಿ ಮತ್ತು ಅಪ್ಲೋಡ್ ಮಾಡಿರಿ. ಸರಿಯು ಮಾನಿಟರ್ನಲ್ಲಿ ಸಂಪರ್ಕವನ್ನು ನೀವು ಕಾಣಬಹುದು:
|
|
|
|
```output
|
|
Connecting to WiFi..
|
|
Connected!
|
|
Fetched NTP epoch time is: 1619983687
|
|
Sending telemetry {"soil_moisture":391}
|
|
The device client is connected to iothub
|
|
```
|
|
|
|
ಔಟ್ಪುಟ್ನಲ್ಲಿ ನೀವು NTP ಸಮಯವನ್ನು ಪಡೆಯುತ್ತಿರುವುದು ಹಾಗೂ ಸಾಧನ ಕ್ಲಯಂಟ್ ಸಂಪರ್ಕ ಸ್ಥಾಪಿಸುತ್ತಿರುವುದನ್ನು ನೋಡಬಹುದು. ಸಂಪರ್ಕ ಸ್ಥಾಪಿಸಲು ಕೆಲವು ಸೆಕೆಂಡುಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು, ಆದ್ದರಿಂದ ಸಾಧನ ಸಂಪರ್ಕ ಹೊತ್ತು ಮಣ್ಣು ಆರ್ದ್ರತೆಯನ್ನು ಔಟ್ಪುಟ್ನಲ್ಲಿ ನೋಡಬಹುದು.
|
|
|
|
> 💁 NTPಗಾಗಿ UNIX ಸಮಯವನ್ನು ಓದಲು ಸುಲಭವಾದ ರೂಪಕ್ಕೆ ಮಾರ್ಪಡಿಸಲು [unixtimestamp.com](https://www.unixtimestamp.com) ಎಂಬ ವೆಬ್ಸೈಟನ್ನು ಬಳಸಬಹುದು.
|
|
|
|
## ಟೆಲಿಮೆಟ್ರಿ ಕಳುಹಿಸಿ
|
|
|
|
ನಿಮ್ಮ ಸಾಧನ ಈಗ ಸಂಪರ್ಕಗೊಂಡಿದ್ದು, ಟೆಲಿಮೆಟ್ರಿಯನ್ನು MQTT ಬ್ರೋಕರ್ ಬದಲಾಗಿ IoT ಹಬ್ಗೆ ಕಳುಹಿಸಬಹುದು.
|
|
|
|
### ಕಾರ್ಯ - ಟೆಲಿಮೆಟ್ರಿ ಕಳುಹಿಸಿ
|
|
|
|
1. `setup` ಫಂಕ್ಷನ್ಗಿಂತ ಮೇಲಾಗಿ ಕೆಳಗಿನ ಫಂಕ್ಷನ್ ಅನ್ನು ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
void sendTelemetry(const char *telemetry)
|
|
{
|
|
IOTHUB_MESSAGE_HANDLE message_handle = IoTHubMessage_CreateFromString(telemetry);
|
|
IoTHubDeviceClient_LL_SendEventAsync(_device_ll_handle, message_handle, NULL, NULL);
|
|
IoTHubMessage_Destroy(message_handle);
|
|
}
|
|
```
|
|
|
|
ಈ ಕೋಡ್ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿ ಪಾಸ್ ಮಾಡಲಾದ IoT ಹಬ್ ಸಂದೇಶವನ್ನು ರಚಿಸುತ್ತದೆ, ಇದನ್ನು ಹಬ್ಬಿಗೆ ಕಳುಹಿಸಿ, ನಂತರ ಸಂದೇಶ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಸ್ವಚ್ಛಮಾಡುತ್ತದೆ.
|
|
|
|
1. `loop` ಫಂಕ್ಷನ್ನಲ್ಲಿ ಟೆಲಿಮೆಟ್ರಿಯನ್ನು ಸರಿಯು ಪೋರ್ಟ್ಗೆ ಕಳುಹಿಸುವ ಲೈನಿನ ನಂತರ ಈ ಕೋಡ್ ಕರೆಮಾಡಿ:
|
|
|
|
```cpp
|
|
sendTelemetry(telemetry.c_str());
|
|
```
|
|
|
|
## ಆದೇಶಗಳನ್ನು ನಿರ್ವಹಿಸಿ
|
|
|
|
ನಿಮ್ಮ ಸಾಧನವು ಸರ್ವರ್ ಕೋಡ್ನಿಂದ ರಿಲೇ ನಿಯಂತ್ರಿಸಲು ಆದೇಶಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕು. ಇದು ನೇರ ಮೆತೋಡ್ ವಿನಂತಿಯಾಗಿ ಕಳುಹಿಸಲಾಗಿದೆ.
|
|
|
|
## ಕಾರ್ಯ - ನೇರ ಮೆತೋಡ್ ವಿನಂತಿಯನ್ನು ನಿರ್ವಹಿಸಿ
|
|
|
|
1. `connectIoTHub` ಫಂಕ್ಷನ್ ಮುಂಚೆ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
int directMethodCallback(const char *method_name, const unsigned char *payload, size_t size, unsigned char **response, size_t *response_size, void *userContextCallback)
|
|
{
|
|
Serial.printf("Direct method received %s\r\n", method_name);
|
|
|
|
if (strcmp(method_name, "relay_on") == 0)
|
|
{
|
|
digitalWrite(PIN_WIRE_SCL, HIGH);
|
|
}
|
|
else if (strcmp(method_name, "relay_off") == 0)
|
|
{
|
|
digitalWrite(PIN_WIRE_SCL, LOW);
|
|
}
|
|
}
|
|
```
|
|
|
|
ಈ ಕೋಡ್ ನೇರ ಮೆತೋಡ್ ವಿನಂತಿಯನ್ನು ಸ್ವೀರುವಾಗಲೆ IoT ಹಬ್ ಲೈಬ್ರರಿ ಕರೆಮಾಡುವ ಕಾಲ್ಬ್ಯಾಕ್ ಮೆತೋದ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ವಿನಂತಿಯ ಮೆತೋಡ್ ಹೆಸರು `method_name` ನಲ್ಲಿ ಬರುತ್ತದೆ. ಈ ಫಂಕ್ಷನ್ ಕರೆಮಾಡಲಾದ ಮೆತೋಡ್ ಅನ್ನು ಸರಿಯು ಪೋರ್ಟ್ಗೆ ಮುದ್ರಿಸುತ್ತದೆ, ನಂತರ ಮೆತೋಡ್ ಹೆಸರಿನಿಂದ ರಿಲೇ ಆನ್ ಅಥವಾ ಆಫ್ ಮಾಡುತ್ತದೆ.
|
|
|
|
> 💁 ಇದನ್ನೇ ಒಂದು ನೇರ ಮೆತೋಡ್ ವಿನಂತಿಯಲ್ಲಿ ಕೂಡ ಅನುಷ್ಠಾನಗೊಳಿಸಬಹುದು, ಮೇತೋದ್ ವಿನಂತಿಯೊಂದಿಗೆ ಪ್ಯಾಸಾಗುವ ಪೇಲೋಡ್ನಲ್ಲಿ ರಿಲೇಯ ಇಚ್ಛಿತ ಸ್ಥಿತಿಯನ್ನು ಪಾಸ್ ಮಾಡಬಹುದು ಮತ್ತು ಅದು `payload` ಪರಿಮಾಣದಿಂದ ಲಭ್ಯವಿರುತ್ತದೆ.
|
|
|
|
1. `directMethodCallback` ಫಂಕ್ಷನ್ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
char resultBuff[16];
|
|
sprintf(resultBuff, "{\"Result\":\"\"}");
|
|
*response_size = strlen(resultBuff);
|
|
*response = (unsigned char *)malloc(*response_size);
|
|
memcpy(*response, resultBuff, *response_size);
|
|
|
|
return IOTHUB_CLIENT_OK;
|
|
```
|
|
|
|
ನೇರ ಮೆತೋಡ್ ವಿನಂತಿಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯೆ ಬೇಕಾಗುತ್ತದೆ, ಇದು ಎರಡು ಭಾಗಗಳಲ್ಲಿದೆ - ಪಠ್ಯ ರೂಪದ ಪ್ರತಿಕ್ರಿಯೆ ಮತ್ತು ಮರುಪ್ರದಾನ ಸಂಕೆತ. ಈ ಕೋಡ್ ಕೆಳಗಿನ JSON ಡಾಕ್ಯುಮೆಂಟ್ ಆಗಿರುವ ಫಲಿತಾಂಶವನ್ನು ರಚಿಸುತ್ತದೆ:
|
|
|
|
```JSON
|
|
{
|
|
"Result": ""
|
|
}
|
|
```
|
|
|
|
ಇದನ್ನು ನಂತರ `response` ಪರಿಮಾಣಕ್ಕೆ ನಕಲಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯ ಗಾತ್ರವನ್ನು `response_size` ನಲ್ಲಿ ಸೆಟ್ ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಕೋಡ್ ನಂತರ `IOTHUB_CLIENT_OK` ಅನ್ನು ಮರುಪ್ರದಾನ ಮಾಡಿ ಮೆತೋಡ್ ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲಾಯಿತು ಎಂದು ತೋರಿಸುತ್ತದೆ.
|
|
|
|
1. ಕಾಲ್ಬ್ಯಾಕ್ ಸಜ್ಜುಗೊಳಿಸಲು `connectIoTHub` ಫಂಕ್ಷನ್ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನದನ್ನು ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
IoTHubClient_LL_SetDeviceMethodCallback(_device_ll_handle, directMethodCallback, NULL);
|
|
```
|
|
|
|
1. `loop` ಫಂಕ್ಷನ್ `IoTHubDeviceClient_LL_DoWork` ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆ ಮಾಡಿ IoT ಹಬ್ ಕಳುಹಿಸುವ ಘಟನೆಗಳನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡುತ್ತದೆ. ಇದನ್ನು `delay` ಕಾರಣದಿಂದ ಪ್ರತಿ 10 ಸೆಕೆಂಡಿಗೆ ಒಮ್ಮೆ ಮಾತ್ರ ಕರೆಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ನೇರ ಮೆತೋಡ್ಗಳು ಪ್ರತಿ 10 ಸೆಕೆಂಡಿಗೆ ಒಂದೇ ಬಾರಿ ಪ್ರಕ್ರಿಯೆಗೊಳ್ಳುತ್ತವೆ. ಇದನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡಲು, 10 ಸೆಕೆಂಡಿನ ವಿಳಂಬವನ್ನು ಬಹು較ಿಸಿದ ಚಿಕ್ಕ ವಿಳಂಬಗಳಾಗಿ ಮಾಡಬಹುದು, ಪ್ರತಿ ಬಾರಿ `IoTHubDeviceClient_LL_DoWork` ಅನ್ನು ಕರೆಮಾಡುತ್ತಾ. ಇದನ್ನು ಮಾಡಲು, `loop` ಫಂಕ್ಷನ್ ಮೇಲ್ಭಾಗಕ್ಕೆ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
|
|
|
|
```cpp
|
|
void work_delay(int delay_time)
|
|
{
|
|
int current = 0;
|
|
do
|
|
{
|
|
IoTHubDeviceClient_LL_DoWork(_device_ll_handle);
|
|
delay(100);
|
|
current += 100;
|
|
} while (current < delay_time);
|
|
}
|
|
```
|
|
|
|
ಈ ಕೋಡ್ ಪುನರಾವರ್ತಿತವಾಗಿ ಲೂಪ್ ಮಾಡುತ್ತದೆ, ಪ್ರತಿ ಬಾರಿ `IoTHubDeviceClient_LL_DoWork` ಅನ್ನು ಕರೆಮಾಡಿ 100ms ವಿಳಂಬ ಮಾಡುತ್ತದೆ. ಇದನ್ನು `delay_time` ಪರಿಮಾಣದಲ್ಲಿ ಸಂದೇಶಿಸಲ್ಪಟ್ಟ ಸಮಯದಷ್ಟು ಸಲ ನಡೆಯುತ್ತದೆ. ಇದರಿಂದ ಸಾಧನವು ನೇರ ಮೆತೋಡ್ ವಿನಂತಿಗಳನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡಲು ಗರಿಷ್ಠ 100ms ಕಾಯುತ್ತದೆ.
|
|
|
|
1. `loop` ಫಂಕ್ಷನ್ನಿಂದ `IoTHubDeviceClient_LL_DoWork` ಕರೆ ತೆಗೆದುಹಾಕಿ ಮತ್ತು `delay(10000)` ಕರೆ ಈ ಹೊಸ ಫಂಕ್ಷನನ್ನು ಕರೆ ಮಾಡುವಂತೆ ಬದಲಾಯಿಸಿ:
|
|
|
|
```cpp
|
|
work_delay(10000);
|
|
```
|
|
|
|
> 💁 ನೀವು ಈ ಕೋಡ್ ಅನ್ನು [code/wio-terminal](../../../../../2-farm/lessons/4-migrate-your-plant-to-the-cloud/code/wio-terminal) ಫೋಲ್ಡರ್ನಲ್ಲಿ ಕಾಣಬಹುದು.
|
|
|
|
😀 ನಿಮ್ಮ ಮಣ್ಣು ಆರ್ದ್ರತೆ ಸಂವೇದಕ ಪ್ರೋಗ್ರಾಂ ನಿಮ್ಮ IoT ಹಬ್ಗೆ ಸಂಪರ್ಕಗೊಂಡಿದೆ!
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**ನೋಟ:**
|
|
ಈ ದಾಖಲೆಯನ್ನು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯು ಸಾಧ್ಯವಿರುವಂತೆ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳು ಇದ್ದಿರಬಹುದು. ಮೂಲ ದಸ್ತಾವೇಜು ಅದರ ಸ್ವಭಾವಿಕ ಭಾಷೆಯಲ್ಲಿರುವ ಬಗೆಗೆ ಪ್ರಮುಖ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಗಮನಾರ್ಹ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ಅರಿವುವಿಕೆ ತಪ್ಪುಗಳು ಅಥವಾ ಅರ್ಥ ತಪ್ಪಾದ ಬಗ್ಗೆ ನಾವು ಹೊಣೆಪಡಿಯುವುದಿಲ್ಲ.
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |