IoT-For-Beginners/translations/kn/6-consumer/lessons/3-spoken-feedback/wio-terminal-set-timer.md

# ಟೈಮರ್ ಸೆಟ್ ಮಾಡಿ - Wio ಟರ್ಮಿನಲ್

ಪಾಠದ ಈ ಭಾಗದಲ್ಲಿ, ನೀವು ಮಾತನಾಡಿದ ಮಾತನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಸರ್ವರ್‌ಲೆಸ್ ಕೋಡ್ ಅನ್ನು ಕರೆಮಾಡುತ್ತೀರಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳ ಆಧಾರದ ಮೇಲೆ ನಿಮ್ಮ Wio ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಟೈಮರ್ ಅನ್ನು ಸೆಟ್ ಮಾಡುತ್ತೀರಿ.

## ಟೈಮರ್ ಸೆಟ್ ಮಾಡುವುದು

Speech to text ಕರೆಮಾಡಿ ಬಂದ ಪಠ್ಯವನ್ನು ನಿಮ್ಮ ಸರ್ವರ್‌ಲೆಸ್ ಕೋಡ್‌ಗೆ ಕಳುಹಿಸುವ ಅಗತ್ಯವಿದೆ, ಅದನ್ನು LUIS ಮೂಲಕ ಪ್ರಕ್ರಿಯೆ ಮಾಡಿ, ಟೈಮರ್‌ನ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತವೆ. ಈ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಟೈಮರ್ ಅನ್ನು ಸೆಟ್ ಮಾಡಲು ಬಳಸಬಹುದು.

ಮೈಕ್ರೋಕಂಟ್ರೋಲರ್‌ಗಳು ಮೂಲತಃ Arduino ನಲ್ಲಿ ಬಹು-ಥ್ರೆಡ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ Python ಅಥವಾ ಇತರ ಮೇಲ್ಅಂಗೀಕೃತ ಭಾಷೆಗಳಂತೆಯೇ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಟೈಮರ್ ಕ್ಲಾಸ್‌ಗಳು ಇರುವುದಿಲ್ಲ. ಬದಲಾಗಿ ನೀವು `loop` ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಕಳೆದ ಸಮಯವನ್ನು ಅಳೆಯುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಟೈಮರ್ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಿ, ಸಮಯ ಮುಗಿದಾಗ ಕಾರ್ಯಗಳನ್ನು ಕರೆ ಮಾಡಬಹುದು.

### ಕಾರ್ಯ - ಪಠ್ಯವನ್ನು ಸರ್ವರ್‌ಲೆಸ್ ಫಂಕ್ಷನ್‌ಗೆ ಕಳುಹಿಸಿ

1. ನೀವು `smart-timer` ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು VS ಕೋಡ್‌ನಲ್ಲಿ ಈಗಾಗಲೇ ತೆರೆಯದಿದ್ದರೆ ತೆರೆಯಿರಿ.

1. `config.h` ಹೆಡರ್ ಫೈಲ್ ತೆರೆಯಿರಿ ಮತ್ತು ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಆ್ಯಪ್ URL ಅನ್ನು ಸೇರಿಸಿ:

    ```cpp
    const char *TEXT_TO_TIMER_FUNCTION_URL = "<URL>";
    ```

    `<URL>` ಅನ್ನು ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಆ್ಯಪ್‌ನ URL ರಿಂದ ಬದಲಾಯಿಸಿ, ಇದು ಕಳೆದ ಪಾಠದ ಕೊನೆಯ ಹಂತದಲ್ಲಿ ಪಡೆದಿದ್ದು, ನಿಮ್ಮ ಲೋಕಲ್ ಮಷಿನ್‌ನ IP ವಿಳಾಸವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಅದು ಫಂಕ್ಷನ್ ಆ್ಯಪ್ ಚಾಲನೆ ಮಾಡುತ್ತಿದೆ.

1. `src` ಫೋಲ್ಡರ್ ನಲ್ಲಿ `language_understanding.h` ಎಂಬ ಹೊಸ ಫೈಲ್ ಸೃಷ್ಟಿಸಿ. ಇದು ಗುರುತಿಸಿದ ಮಾತನಾಡುವ ಪಠ್ಯವನ್ನು ಸೆಕೆಂಡುಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು LUIS ಬಳಸಿ ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಆ್ಯಪ್‌ಗೆ ಕಳುಹಿಸಲು ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

1. ಈ ಫೈಲ್‌ನ ಟಾಪ್‌ಗೆ ಕೆಳಗಿನ ವಿಷಯವನ್ನು ಸೇರಿಸಿ:

    ```cpp
    #pragma once
    
    #include <Arduino.h>
    #include <ArduinoJson.h>
    #include <HTTPClient.h>
    #include <WiFiClient.h>
    
    #include "config.h"
    ```

    ಇದು ಕೆಲವು ಅಗತ್ಯ ಹೆಡರ್ ಫೈಲ್‌ಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ.

1. `LanguageUnderstanding` ಎಂಬ ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ ಮತ್ತು ಈ ವರ್ಗದ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ಘೋಷಿಸಿ:

    ```cpp
    class LanguageUnderstanding
    {
    public:
    private:
    };

    LanguageUnderstanding languageUnderstanding;
    ```

1. ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಆ್ಯಪ್ ಅನ್ನು ಕರೆಮಾಡಲು WiFi ಕ್ಲೈಂಟ್ ಅನ್ನು ಘೋಷಿಸುವ ಅಗತ್ಯವಿದೆ. ವರ್ಗದ `private` ವಿಭಾಗದಲ್ಲಿ ಕೆಳಗಿನುದನ್ನು ಸೇರಿಸಿ:

    ```cpp
    WiFiClient _client;
    ```

1. `public` ವಿಭಾಗದಲ್ಲಿ, ಫಂಕ್ಷನ್ ಆ್ಯಪ್ ಅನ್ನು ಕರೆಮಾಡಲು `GetTimerDuration` ಎಂಬ ವಿಧಾನವನ್ನು ಘೋಷಿಸಿ:

    ```cpp
    int GetTimerDuration(String text)
    {
    }
    ```

1. `GetTimerDuration` ವಿಧಾನದಲ್ಲಿ, ಫಂಕ್ಷನ್ ಆ್ಯಪ್‌ಗೆ ಕಳುಹಿಸುವ JSON ಅನ್ನು ನಿರ್ಮಿಸಲು ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸಿ:

    ```cpp
    DynamicJsonDocument doc(1024);
    doc["text"] = text;

    String body;
    serializeJson(doc, body);
    ```

    ಇದು `GetTimerDuration` ವಿಧಾನಕ್ಕೆ ಪಠ್ಯವನ್ನು JSON ರಚನೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ:

    ```json
    {
        "text" : "<text>"
    }
    ```

    ಇಲ್ಲಿ `<text>` ಎಂಬುದು ಫಂಕ್ಷನ್‌ಗೆ ಕಳುಹಿಸುವ ಪಠ್ಯ.

1. ಇದರ ಕೆಳಗೆ, ಫಂಕ್ಷನ್ ಆ್ಯಪ್ ಕರೆ ಮಾಡಲು ಈ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    HTTPClient httpClient;
    httpClient.begin(_client, TEXT_TO_TIMER_FUNCTION_URL);

    int httpResponseCode = httpClient.POST(body);
    ```

    ಇದು functions ಆ್ಯಪ್‌ಗೆ POST ವಿನಂತಿ ಮಾಡುತ್ತದೆ, JSON ದೇಹವನ್ನು ಕಳುಹಿಸಿ ಪ್ರತಿಕ್ರિયા ಕೋಡ್ ಪಡೆಯುತ್ತದೆ.

1. ಇದರ ಕೆಳಗೆ ಈ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸಿ:

    ```cpp
    int seconds = 0;
    if (httpResponseCode == 200)
    {
        String result = httpClient.getString();
        Serial.println(result);

        DynamicJsonDocument doc(1024);
        deserializeJson(doc, result.c_str());

        JsonObject obj = doc.as<JsonObject>();
        seconds = obj["seconds"].as<int>();
    }
    else
    {
        Serial.print("Failed to understand text - error ");
        Serial.println(httpResponseCode);
    }
    ```

    ಇದು ಪ್ರತಿಕ್ರಿಯಾ ಕೋಡ್ ಪರಿಶೀಲಿಸುತ್ತದೆ. 200 (ಯಶಸ್ವೀ) ಆಗಿದ್ದರೆ, ಪ್ರತಿಕ್ರಿಯಾ ದೇಹದಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆ ಪಡೆಯಲಾಗುತ್ತದೆ. ಇಲ್ಲದಿದ್ದಲ್ಲಿ ದೋಷವನ್ನು ಸೀರಿಯಲ್ ಮೊಂಡಿಟರ್ ಗೆ ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆ 0 ಆಗಿರುತ್ತದೆ.

1. ಈ ವಿಧಾನದ ಕೊನೆಯಲ್ಲಿ HTTP ಸಂಪರ್ಕವನ್ನು ಮುಚ್ಚಲು ಮತ್ತು ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ವಾಪಸು ನೀಡಲು ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    httpClient.end();

    return seconds;
    ```

1. `main.cpp` ಫೈಲ್‌ನಲ್ಲಿ ಈ ಹೊಸ ಹೆಡರ್ ಅನ್ನು ಸೇರಿಸಿ:

    ```cpp
    #include "speech_to_text.h"
    ```

1. `processAudio` ವಿಧಾನದ ಕೊನೆಯಲ್ಲಿ, `GetTimerDuration` ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿ ಟೈಮರ್ ಅವಧಿಯನ್ನು ಪಡೆಯಿರಿ:

    ```cpp
    int total_seconds = languageUnderstanding.GetTimerDuration(text);
    ```

    ಇದು `SpeechToText` ವರ್ಗದಿಂದ ಬಂದ ಪಠ್ಯವನ್ನು ಟೈಮರ್ ಅವಧಿಗೆ ಅಗತ್ಯವಾದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.

### ಕಾರ್ಯ - ಟೈಮರ್ ಸೆಟ್ ಮಾಡುವುದು

ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಟೈಮರ್ ಸೆಟ್ ಮಾಡಲು ಬಳಸಬಹುದು.

1. `platformio.ini` ಫೈಲ್‌ಗೆ ಕೆಳಗಿನ ಲೈಬ್ರರಿ ಅವಲಂಬನೆಯನ್ನು ಸೇರಿಸಿ ಟೈಮರ್ ಸೆಟ್ ಮಾಡಲು ಲೈಬ್ರರಿ ಸೇರಿಸಲು:

    ```ini
    contrem/arduino-timer @ 2.3.0
    ```

1. ಈ ಲೈಬ್ರರಿಗೆ `main.cpp` ಫೈಲ್‌ನಲ್ಲಿ include ನಿರ್ದೇಶನವನ್ನು ಸೇರಿಸಿ:

    ```cpp
    #include <arduino-timer.h>
    ```

1. `processAudio` ವಿಧಾನದ ಮೇಲ್ಮೈಯಲ್ಲಿ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    auto timer = timer_create_default();
    ```

    ಈ ಕೋಡ್ `timer` ಎಂಬ ಟೈಮರ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ.

1. ಇದರ ಕೆಳಗೆ, ಈ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    void say(String text)
    {
        Serial.print("Saying ");
        Serial.println(text);
    }
    ```

    ಈ `say` ಫಂಕ್ಷನ್ ಅಂತಿಮವಾಗಿ ಪಠ್ಯವನ್ನು ಮಾತನಾಡುವ್ಯವಸ್ಥೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಆದರೆ ಈಗಿಗೆ ಇದನ್ನು ಸೀರಿಯಲ್ ಮೊಂಡಿಟರ್ ಗೆ ಪಠ್ಯವನ್ನು ಬರೆಯುತ್ತದೆ.

1. `say` ಫಂಕ್ಷನ್ ಕೆಳಗೆ, ಈ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    bool timerExpired(void *announcement)
    {
        say((char *)announcement);
        return false;
    }
    ```

    ಇದು ಟೈಮರ್ ಅವಧಿ ಮುಗಿದಾಗ ಕರೆಮಾಡಲಾಗುವ ಕಾರ್-ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್. ಟೈಮರ್ ಸಮಯ ಮುಗಿದಾಗ ಹೇಳಬೇಕಾದ ಸಂದೇಶವನ್ನು ಪರಿಷ್ಕರಿಸಲಾಗುತ್ತದೆ. ಟೈಮರ್‌ಗಳು ಪುನರಾವರ್ತಿಸಬಹುದಾಗಿವೆ ಮತ್ತು ಈ ಕಾರ್ಯಾಚರಣೆ ಕಾರ್-ಬ್ಯಾಕ್ ಪ್ರತಿಕ್ರಿಯೆಯಿಂದ ನಿಯಂತ್ರಿಸಲ್ಪಡುತ್ತದೆ — ಇದು `false` ಅನ್ನು ವಾಪಸು ನೀಡುತ್ತದೆ, ಟೈಮರ್‌ ಮತ್ತೆ ಚಾಲನೆ ಆಗಬಾರದಂತೆ ಸೂಚಿಸಲು.

1. `processAudio` ವಿಧಾನದ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    if (total_seconds == 0)
    {
        return;
    }

    int minutes = total_seconds / 60;
    int seconds = total_seconds % 60;
    ```

    ಈ ಕೋಡ್ ಒಟ್ಟು ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, 0 ಇದ್ದರೆ ಕಾರ್ಯಾಚರಣೆ ಹಿಂತಿರುಗುತ್ತದೆ ಹಾಗಾಗಿ ಯಾವುದೇ ಟೈಮರ್ ಸೆಟ್ ಆಗುವುದಿಲ್ಲ. ನಂತರ ಒಟ್ಟು ಸೆಕೆಂಡುಗಳನ್ನು ನಿಮಿಷಗಳು ಮತ್ತು ಸೆಕೆಂಡುಗಳಿಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.

1. ಈ ಕೋಡ್ ಕೆಳಗೆ, ಟೈಮರ್ ಆರಂಭಿಸಿದಾಗ ಹೇಳಬೇಕಾದ ಸಂದೇಶವನ್ನು ರಚಿಸಲು ಈ ಮುಂದಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    String begin_message;
    if (minutes > 0)
    {
        begin_message += minutes;
        begin_message += " minute ";
    }
    if (seconds > 0)
    {
        begin_message += seconds;
        begin_message += " second ";
    }

    begin_message += "timer started.";
    ```

1. ಇದರ ಕೆಳಗೆ, ಟೈಮರ್ ಅವಧಿ ಮುಗಿದಾಗ ಹೇಳಬೇಕಾದ ಸಂದೇಶದ ಹೋಲಿಸಿದ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    String end_message("Times up on your ");
    if (minutes > 0)
    {
        end_message += minutes;
        end_message += " minute ";
    }
    if (seconds > 0)
    {
        end_message += seconds;
        end_message += " second ";
    }

    end_message += "timer.";
    ```

1. ಇದರ ನಂತರ, ಟೈಮರ್ ಪ್ರಾರಂಭ ಸಂದೇಶವನ್ನು ಹೇಳಿ:

    ```cpp
    say(begin_message);
    ```

1. ಈ ಕಾರ್ಯಾಚರಣೆಯ ಕೊನೆಯಲ್ಲಿ, ಟೈಮರ್ ಪ್ರಾರಂಭಿಸಿ:

    ```cpp
    timer.in(total_seconds * 1000, timerExpired, (void *)(end_message.c_str()));
    ```

    ಇದರಿಂದ ಟೈಮರ್ ಪ್ರಾರಂಭಗೊಳ್ಳುತ್ತದೆ. ಟೈಮರ್ ಮಿಲಿಸೆಕೆಂಡುಗಳಲ್ಲಿ ಸೆಟ್ ಆಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಒಟ್ಟು ಸೆಕೆಂಡುಗಳನ್ನು 1,000 ರೊಂದಿಗೆ ಗುಣಿಸಬೇಕು ಮಿಲಿಸೆಕೆಂಡುಗಳಾಗಿ ಪರಿವರ್ತಿಸಲು. `timerExpired` ಫಂಕ್ಷನ್ ಕಾರ್-ಬ್ಯಾಕ್ ಆಗಿ ಪಾಸ್ ಆಗುತ್ತದೆ ಮತ್ತು `end_message` ಕಾರ್-ಬ್ಯಾಕ್‌ಗೆ_ARGUMENTS_ ಆಗಿ ಪಾಸ್ ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಕಾರ್-ಬ್ಯಾಕ್ ವೈ_void*_Argument ಗೆ ಮಾತ್ರ ಸ್ವೀಕಾರ, ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ ಸರಿಯಾಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ.

1. ಕೊನೆಗೆ, ಟೈಮರ್ ಅನ್ನು *ಟಿಕ್* ಮಾಡಬೇಕು, ಮತ್ತು ಇದು `loop` ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ. `loop` ಫಂಕ್ಷನ್ ಕೆಳಗೆ ಈ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    timer.tick();
    ```

1. ಈ ಕೋಡ್ ಅನ್ನು ನಿರ್ಮಿಸಿ, ನಿಮ್ಮ Wio ಟರ್ಮಿನಲ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಸೀರಿಯಲ್ ಮೊಂಡಿಟರ್ ಮೂಲಕ ಪರೀಕ್ಷಿಸಿ. ಸೀರಿಯಲ್ ಮೊಂಡಿಟರ್‌ನಲ್ಲಿ `Ready` ಅನ್ನು ನೋಡಿದ ನಂತರ C ಬಟನ್ (ಎಡ ಬದಿ, ಪವರ್ ಸ್ವಿಚ್‌ಗೆ ಅಕ್ಕಟ್ಟಾಗಿ) ಒತ್ತಿ ಮತ್ತು ಮಾತಾಡಿ. 4 ಸೆಕೆಂಡುಗಳ ಆಡಿಯೋ ಹಿಡಿಯೋದು, ಪಠ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲಾಗುವುದು, ನಂತರ ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಆ್ಯಪ್‌ಗೆ ಕಳುಹಿಸಲಾಗುವುದು ಮತ್ತು ಟೈಮರ್ ಸೆಟ್ ಆಗುವುದು. ನಿಮ್ಮ ಫಂಕ್ಶನ್ ಆ್ಯಪ್ ಸ್ಥಳೀಯವಾಗಿ ಚಲಿಸುತ್ತಿರುವುದಾಗಿ ಖಚಿತಪಡಿಸಿಕೊಂಡಿರಿ.

    ನೀವು ಟೈಮರ್ ಪ್ರಾರಂಭವಾಗುವಾಗ ಮತ್ತು ಮುಗಿಯುವಾಗ ನೋಡಬಹುದು.

    ```output
    --- Available filters and text transformations: colorize, debug, default, direct, hexlify, log2file, nocontrol, printable, send_on_enter, time
    --- More details at http://bit.ly/pio-monitor-filters
    --- Miniterm on /dev/cu.usbmodem1101  9600,8,N,1 ---
    --- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
    Connecting to WiFi..
    Connected!
    Got access token.
    Ready.
    Starting recording...
    Finished recording
    Sending speech...
    Speech sent!
    {"RecognitionStatus":"Success","DisplayText":"Set a 2 minute and 27 second timer.","Offset":4700000,"Duration":35300000}
    Set a 2 minute and 27 second timer.
    {"seconds": 147}
    2 minute 27 second timer started.
    Times up on your 2 minute 27 second timer.
    ```

> 💁 ಈ ಕೋಡ್ ಅನ್ನು [code-timer/wio-terminal](../../../../../6-consumer/lessons/3-spoken-feedback/code-timer/wio-terminal) ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬಹುದು.

😀 ನಿಮ್ಮ ಟೈಮರ್ ಪ್ರೋಗ್ರಾಂ ಯಶಸ್ವಿಯಾಗಿದೆ!

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ತಡೆಬಿಡುವಿಕೆ**:  
ಈ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು AI ಅನುವಾದ ಸೇವೆಯಾದ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸುವುದಾದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪು ಮಾಹಿತಿ ಇರಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿನ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತೆ. ಪ್ರಮುಖ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಸಲಹೆ ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದದ ಬಳಕೆಯಿಂದ ಉಂಟಾದ ಯಾವುದೇ ದುರ್ಬೋಧನೆಗಳಿಗೆ ಅಥವಾ ತಾಲ್ಮೆಯ ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗಿರುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->