# ನಿಮ್ಮ 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 -->