22 KiB

Raw Permalink Blame History

ನಿಮ್ಮ IoT ಸಾಧನವನ್ನು ಕ್ಲೌಡ್‌ಗೆ ಸಂಪರ್ಕಿಸಿ - Wio ಟರ್ಮಿನಲ್

ಪಾಠದ ಈ ಭಾಗದಲ್ಲಿ, ನೀವು ನಿಮ್ಮ Wio ಟರ್ಮಿನಲ್ ಅನ್ನು ನಿಮ್ಮ IoT ಹಬ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಿಸಿ, ಟೆಲಿಮೆಟ್ರಿ ಕಳುಹಿಸುವುದು ಮತ್ತು ಆದೇಶಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದು.

ನಿಮ್ಮ ಸಾಧನವನ್ನು IoT ಹಬ್‌ಗೆ ಸಂಪರ್ಕಿಸಿ

ಮುಂದಿನ ಹಂತ ನಿಮ್ಮ ಸಾಧನವನ್ನು IoT ಹಬ್‌ಗೆ ಸಂಪರ್ಕಿಸುವುದು.

ಕಾರ್ಯ - IoT ಹಬ್‌ಗೆ ಸಂಪರ್ಕಿಸಿ

VS ಕೋಡ್‌ನಲ್ಲಿ soil-moisture-sensor ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ತೆರೆಯಿರಿ
platformio.ini ಫೈಲನ್ನು ತೆರೆಯಿರಿ. knolleary/PubSubClient ಲೈಬ್ರರಿ ಅವಲಂಬನೆಯನ್ನು ತೆಗೆದುಹಾಕಿ. ಇದು ಸಾರ್ವಜನಿಕ MQTT ಬ್ರೋಕರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಬಳಸಲಾಗುತ್ತಿದ್ದಿದ್ದು, IoT ಹಬ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಅಗತ್ಯವಿಲ್ಲ.
ಕೆಳಗಿನ ಲೈಬ್ರರಿ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರಿಸಿ:
```
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 ಹಬ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಅನುಮತಿಸುತ್ತವೆ.
platformio.ini ಫೈಲಿನ ಕೆಳಭಾಗಕ್ಕೆ ಕೆಳಗಿನ ಬರಹ ಸೇರಿಸಿ:
```
build_flags =
    -DDONT_USE_UPLOADTOBLOB
```
ಇದು ಆರ್ಡಿನೋ IoT ಹಬ್ ಕೋಡ್ ಸಂकलಿಸುವಾಗ ಅಗತ್ಯವಿರುವ ಸಂಕಲಕ ಧ್ವಜವನ್ನು ಸೆಟ್ ಮಾಡುತ್ತದೆ.
config.h ಹೆಡರ್ ಫೈಲನ್ನು ತೆರೆಯಿರಿ. ಎಲ್ಲಾ MQTT ಸೆಟ್ಟಿಂಗ್ಗಳನ್ನು ತೆಗೆದುಹಾಕಿ ಮತ್ತು ಸಾಧನ ಸಂಪರ್ಕ ಸರಣಿಗಾಗಿ ಕೆಳಗಿನ ಸ್ಥಿರಾಂಕವನ್ನು ಸೇರಿಸಿ:
```
// ಐಒಟಿ ಹಬ್ ಸೆಟ್ಟಿಂಗ್ಗಳು
const char *CONNECTION_STRING = "<connection string>";
```
<connection string> ಅನ್ನು ನೀವು ಮೊದಲು ನಕಲಿಸಿದ ನಿಮ್ಮ ಸಾಧನದ ಸಂಪರ್ಕ ಸರಣಿಯಿಂದ ಬದಲಾಯಿಸಿ.
IoT ಹಬ್‌ಗೆ ಸಂಪರ್ಕಿಸುವುದು ಸಮಯ-ಆಧಾರಿತ ಟೋಕನ್ ಬಳಸುತ್ತದೆ. ಇದರಿಂದ IoT ಸಾಧನವು ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು. ವಿಂಡೋಸ್, ಮಾಕ್‌ಒಎಸ್ ಅಥವಾ ಲಿನಕ್ಸಿನಂತಹ ಕಾರ್ಯಾಚರಣೆ ವ್ಯವಸ್ಥೆಗಳಂತೆ, ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್‌ಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಇಂಟರ್ನೆಟ್ ಮೂಲಕ ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುತ್ತಿಲ್ಲ. ಹಾಗಾಗಿ ನೀವು NTP ಸರ್ವರ್‌ನಿಂದ ಪ್ರಸ್ತುತ ಸಮಯ ಪಡೆಯಲು ಕೋಡ್ ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ. ಸಮಯ ಪಡೆಯಾದ ನಂತರ, ಇದು Wio ಟರ್ಮಿನಲ್‌ನಲ್ಲಿನ ನಿಜ ಸಮಯ ಘಡಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದಾಗಿದೆ, ಸಾಧನ ವಿದ್ಯುತ್ ಕಳೆದುಕೊಳ್ಳದಿದ್ದರೆ, ನಂತರ ಸರಿಯಾದ ಸಮಯವನ್ನು ಕೇಳಬಹುದು. ntp.h ಎಂಬ ಹೊಸ ಫೈಲ್ ಅನ್ನು ಕೆಳಗಿನ ಕೋಡ್‌ನೊಂದಿಗೆ ಸೇರಿಸಿ:
```
#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 ಟರ್ಮಿನಲ್‌ನ ಘಡಿಯನ್ನು ಸೆಟ್ ಮಾಡಲು ಬಳಸುತ್ತದೆ.
main.cpp ಫೈಲನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಎಲ್ಲಾ MQTT ಕೋಡ್‌ನ್ನು, PubSubClient.h ಹೆಡರ್ ಫೈಲ್, PubSubClient ಚರ ಮತ್ತು ಅದರ reconnectMQTTClient, createMQTTClient ಮೆತೋಡ್‌ಗಳ ಘೋಷಣೆ ಮತ್ತು ಇವುಗಳಿಗೆ ಕರೆಗಳನ್ನು ತೆಗೆದುಹಾಕಿ. ಈ ಫೈಲ್ ಕೇವಲ ವೈಫೈಗೆ ಸಂಪರ್ಕಿಸಲು, ಮಣ್ಣು ಆರ್ದ್ರತೆಯನ್ನು ಪಡೆಯಲು ಮತ್ತು ಅದನ್ನು JSON ಡಾಕ್ಯುಮೆಂಟ್‌ನಲ್ಲಿ ತಯಾರಿಸಲು ಕೋಡ್ ಹೊಂದಿರಬೇಕು.
main.cpp ಫೈಲಿನ ಮೇಲ್ಭಾಗಕ್ಕೆ ಕೆಳಗಿನ #include ಸೂಚನೆಗಳನ್ನು ಸೇರಿಸಿ, ಇದು IoT ಹಬ್ ಲೈಬ್ರರಿಗಳ ಮತ್ತು ಸಮಯ ಸೆಟ್ಟಿಂಗ್‌ಗಾಗಿ ಹೆಡರ್ ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:
```
#include <AzureIoTHub.h>
#include <AzureIoTProtocol_MQTT.h>
#include <iothubtransportmqtt.h>
#include "ntp.h"
```
ಪ್ರಸ್ತುತ ಸಮಯವನ್ನು ಸೆಟ್ ಮಾಡಲು setup ಫಂಕ್ಷನ್‌ನ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನ ಕರೆ ಸೇರಿಸಿ:
```
initTime();
```
ಫೈಲಿನ ಮೇಲ್ಭಾಗದಲ್ಲಿ, ಇಂಕ್ಲೂಡ್ ಸೂಚನೆಗಳ ಕೆಳಗೆ ಈ ಚರ ಘೋಷಣೆಯನ್ನು ಸೇರಿಸಿ:
```
IOTHUB_DEVICE_CLIENT_LL_HANDLE _device_ll_handle;
```
ಇದು IOTHUB_DEVICE_CLIENT_LL_HANDLE ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ, ಇದು IoT ಹಬ್‌ಗೆ ಸಂಪರ್ಕ ಹ್ಯಾಂಡಲ್ ಆಗಿದೆ.
ಇದರ ಕೆಳಗೆ, ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
```
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");
    }
}
```
ಇದು ಕೊನೆಗೆ ಸಂಪರ್ಕ ಸ್ಥಿತಿ ಬದಲಾವಣೆಗಳನ್ನು ತೋರಿಸಲು ಕರೆಮಾಡುವ ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಆಗಿದ್ದು, ಉದಾಹರಣೆಗೆ ಸಂಪರ್ಕ ಅಥವಾ ಬಿಚ್ಚುವುದು. ಸ್ಥಿತಿಯನ್ನು ಸರಿಯು ಪೋರ್ಟ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.
ಇದರ ಕೆಳಗೆ, IoT ಹಬ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಫಂಕ್ಷನ್ ಸೇರಿಸಿ:
```
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 ಆಧಾರಿತ ಸಂಪರ್ಕವನ್ನು ರಚಿಸುತ್ತದೆ. ಸಂಪರ್ಕ ವಿಫಲವಾದರೆ, ಇದು ಸರಿಯು ಪೋರ್ಟ್‌ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ—ನೀವು ಇದನ್ನು ನಿಮಗೆ ದೊರಕುವ ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ನೋಡಿದರೆ ಸಂಪರ್ಕ ಸರಣಿಯನ್ನು ಪರಿಶೀಲಿಸಿ. ಕೊನೆಗೆ ಸಂಪರ್ಕ ಸ್ಥಿತಿ ಕಾಲ್‌ಬ್ಯಾಕ್ ಹೊಂದಿಸಲಾಗಿದೆ.
ಈ ಫಂಕ್ಷನ್ ಅನ್ನು setup ಫಂಕ್ಷನ್‌ನಲ್ಲಿ initTime ಕರೆ ನಂತರ ಕರೆಮಾಡಿ:
```
connectIoTHub();
```
MQTT ಕ್ಲಯಂಟ್‌ನಂತೆ, ಈ ಕೋಡ್ ಒಬ್ಬ ಏಕಕಾಲೀನ ತಂತೆಯಲ್ಲಿ ಚಲಿಸುತ್ತದೆ ಹಾಗಾಗಿ ಹಬ್ ಕಳುಹಿಸುವ ಮತ್ತು ಸ್ವೀಕರಿಸುವ ಸಂದೇಶಗಳನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡಲು ಸಮಯ ಬೇಕಾಗುತ್ತದೆ. ಈ ಕಾರ್ಯಕ್ಕೂ loop ಫಂಕ್ಷನ್‌ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಕೆಳಗಿನ ಬರಹ ಸೇರಿಸಿ:
```
IoTHubDeviceClient_LL_DoWork(_device_ll_handle);
```
ಈ ಕೋಡ್ ನಿರ್ಮಿಸಿ ಮತ್ತು ಅಪ್ಲೋಡ್ ಮಾಡಿರಿ. ಸರಿಯು ಮಾನಿಟರ್‌ನಲ್ಲಿ ಸಂಪರ್ಕವನ್ನು ನೀವು ಕಾಣಬಹುದು:
```
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 ಎಂಬ ವೆಬ್‌ಸೈಟನ್ನು ಬಳಸಬಹುದು.

ಟೆಲಿಮೆಟ್ರಿ ಕಳುಹಿಸಿ

ನಿಮ್ಮ ಸಾಧನ ಈಗ ಸಂಪರ್ಕಗೊಂಡಿದ್ದು, ಟೆಲಿಮೆಟ್ರಿಯನ್ನು MQTT ಬ್ರೋಕರ್ ಬದಲಾಗಿ IoT ಹಬ್‌ಗೆ ಕಳುಹಿಸಬಹುದು.

ಕಾರ್ಯ - ಟೆಲಿಮೆಟ್ರಿ ಕಳುಹಿಸಿ

setup ಫಂಕ್ಷನ್‌ಗಿಂತ ಮೇಲಾಗಿ ಕೆಳಗಿನ ಫಂಕ್ಷನ್ ಅನ್ನು ಸೇರಿಸಿ:
```
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 ಹಬ್ ಸಂದೇಶವನ್ನು ರಚಿಸುತ್ತದೆ, ಇದನ್ನು ಹಬ್ಬಿಗೆ ಕಳುಹಿಸಿ, ನಂತರ ಸಂದೇಶ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಸ್ವಚ್ಛಮಾಡುತ್ತದೆ.
loop ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಟೆಲಿಮೆಟ್ರಿಯನ್ನು ಸರಿಯು ಪೋರ್ಟ್‌ಗೆ ಕಳುಹಿಸುವ ಲೈನಿನ ನಂತರ ಈ ಕೋಡ್ ಕರೆಮಾಡಿ:
```
sendTelemetry(telemetry.c_str());
```

ಆದೇಶಗಳನ್ನು ನಿರ್ವಹಿಸಿ

ನಿಮ್ಮ ಸಾಧನವು ಸರ್ವರ್ ಕೋಡ್‌ನಿಂದ ರಿಲೇ ನಿಯಂತ್ರಿಸಲು ಆದೇಶಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕು. ಇದು ನೇರ ಮೆತೋಡ್ ವಿನಂತಿಯಾಗಿ ಕಳುಹಿಸಲಾಗಿದೆ.

ಕಾರ್ಯ - ನೇರ ಮೆತೋಡ್ ವಿನಂತಿಯನ್ನು ನಿರ್ವಹಿಸಿ

connectIoTHub ಫಂಕ್ಷನ್ ಮುಂಚೆ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
```
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 ಪರಿಮಾಣದಿಂದ ಲಭ್ಯವಿರುತ್ತದೆ.
directMethodCallback ಫಂಕ್ಷನ್ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
```
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 ಡಾಕ್ಯುಮೆಂಟ್ ಆಗಿರುವ ಫಲಿತಾಂಶವನ್ನು ರಚಿಸುತ್ತದೆ:
```
{
    "Result": ""
}
```
ಇದನ್ನು ನಂತರ response ಪರಿಮಾಣಕ್ಕೆ ನಕಲಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯ ಗಾತ್ರವನ್ನು response_size ನಲ್ಲಿ ಸೆಟ್ ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಕೋಡ್ ನಂತರ IOTHUB_CLIENT_OK ಅನ್ನು ಮರುಪ್ರದಾನ ಮಾಡಿ ಮೆತೋಡ್ ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲಾಯಿತು ಎಂದು ತೋರಿಸುತ್ತದೆ.
ಕಾಲ್‌ಬ್ಯಾಕ್ ಸಜ್ಜುಗೊಳಿಸಲು connectIoTHub ಫಂಕ್ಷನ್ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನದನ್ನು ಸೇರಿಸಿ:
```
IoTHubClient_LL_SetDeviceMethodCallback(_device_ll_handle, directMethodCallback, NULL);
```
loop ಫಂಕ್ಷನ್ IoTHubDeviceClient_LL_DoWork ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆ ಮಾಡಿ IoT ಹಬ್ ಕಳುಹಿಸುವ ಘಟನೆಗಳನ್ನು ಪ್ರಕ್ರಿಯೆ ಮಾಡುತ್ತದೆ. ಇದನ್ನು delay ಕಾರಣದಿಂದ ಪ್ರತಿ 10 ಸೆಕೆಂಡಿಗೆ ಒಮ್ಮೆ ಮಾತ್ರ ಕರೆಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ನೇರ ಮೆತೋಡ್‌ಗಳು ಪ್ರತಿ 10 ಸೆಕೆಂಡಿಗೆ ಒಂದೇ ಬಾರಿ ಪ್ರಕ್ರಿಯೆಗೊಳ್ಳುತ್ತವೆ. ಇದನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡಲು, 10 ಸೆಕೆಂಡಿನ ವಿಳಂಬವನ್ನು ಬಹು較ಿಸಿದ ಚಿಕ್ಕ ವಿಳಂಬಗಳಾಗಿ ಮಾಡಬಹುದು, ಪ್ರತಿ ಬಾರಿ IoTHubDeviceClient_LL_DoWork ಅನ್ನು ಕರೆಮಾಡುತ್ತಾ. ಇದನ್ನು ಮಾಡಲು, loop ಫಂಕ್ಷನ್ ಮೇಲ್ಭಾಗಕ್ಕೆ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
```
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 ಕಾಯುತ್ತದೆ.
loop ಫಂಕ್ಷನ್‌ನಿಂದ IoTHubDeviceClient_LL_DoWork ಕರೆ ತೆಗೆದುಹಾಕಿ ಮತ್ತು delay(10000) ಕರೆ ಈ ಹೊಸ ಫಂಕ್ಷನನ್ನು ಕರೆ ಮಾಡುವಂತೆ ಬದಲಾಯಿಸಿ:
```
work_delay(10000);
```

💁 ನೀವು ಈ ಕೋಡ್ ಅನ್ನು code/wio-terminal ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಕಾಣಬಹುದು.

😀 ನಿಮ್ಮ ಮಣ್ಣು ಆರ್ದ್ರತೆ ಸಂವೇದಕ ಪ್ರೋಗ್ರಾಂ ನಿಮ್ಮ IoT ಹಬ್‌ಗೆ ಸಂಪರ್ಕಗೊಂಡಿದೆ!

ನೋಟ:
ಈ ದಾಖಲೆಯನ್ನು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯು ಸಾಧ್ಯವಿರುವಂತೆ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುಗಳು ಇದ್ದಿರಬಹುದು. ಮೂಲ ದಸ್ತಾವೇಜು ಅದರ ಸ್ವಭಾವಿಕ ಭಾಷೆಯಲ್ಲಿರುವ ಬಗೆಗೆ ಪ್ರಮುಖ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಗಮನಾರ್ಹ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ಅರಿವುವಿಕೆ ತಪ್ಪುಗಳು ಅಥವಾ ಅರ್ಥ ತಪ್ಪಾದ ಬಗ್ಗೆ ನಾವು ಹೊಣೆಪಡಿಯುವುದಿಲ್ಲ.

22 KiB Raw Permalink Blame History