# Speech to text - Wio Terminal

ಈ ಪಾಠದ ಈ ಭಾಗದಲ್ಲಿ, ನೀವು ಹಿಡಿದಿಟ್ಟುಕೊಂಡ ಧ್ವನಿಯನ್ನು ಟೆಕ್ಸ್ಟ್ ಗೆ ಪರಿವರ್ತಿಸುವುದಕ್ಕಾಗಿ ಸ್ಪೀಚ್ ಸರ್ವೀಸ್ ಬಳಸಿ ಕೋಡ್ ಅನ್ನು ಬರೆಯಲಿದ್ದೀರಿ.

## ಧ್ವನಿಯನ್ನು ಸ್ಪೀಚ್ ಸರ್ವೀಸ್ ಗೆ ಕಳುಹಿಸಿ

ಧ್ವನಿಯನ್ನು REST API ಬಳಸಿ ಸ್ಪೀಚ್ ಸರ್ವೀಸ್ ಗೆ ಕಳುಹಿಸಬಹುದು. ಸ್ಪೀಚ್ ಸರ್ವೀಸ್ ಅನ್ನು ಬಳಸಲು, ಮೊದಲು ನೀವು ಒಂದು ಪ್ರವೇಶ ಟೋಕನ್ ಕೇಳಿಕೊಳ್ಳಬೇಕು, ನಂತರ ಆ ಟೋಕನ್ ಬಳಸಿ REST API ಗೆ ಪ್ರವೇಶಿಸಬೇಕು. ಇವು 10 ನಿಮಿಷಗಳ ಬಳಿಕ ಅವಧಿ ಮುಗಿಸುವುದರಿಂದ, ನಿಮ್ಮ ಕೋಡ್ ನಿಯಮಿತವಾಗಿ ಟೋಕನ್ ಗಳನ್ನು ಕೇಳಿಕೊಳ್ಳಬೇಕು ಹಾಗಾಗಿ ಅವು ಯಾವಾಗಲೂ ನವೀಕರಿಸಲ್ಪಟ್ಟಿರುತ್ತವೆ.

### ಕಾರ್ಯ - ಪ್ರವೇಶ ಟೋಕನ್ ಪಡೆಯಿರಿ

1. `smart-timer` ಪ್ರಾಜೆಕ್ಟ್ ಈಗಾಗಲೇ തുറಕೊಳ್ಳದಿದ್ದರೆ ತೆರೆಯಿರಿ.

1. WiFi ಗೆ ಪ್ರವೇಶ ಮತ್ತು JSON ನಿರ್ವಹಣೆಗೆ `platformio.ini` ಫೈಲ್‌ಗೆ ಕೆಳಗಿನ ಲೈಬ್ರರಿ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರಿಸಿ:

    ```ini
    seeed-studio/Seeed Arduino rpcWiFi @ 1.0.5
    seeed-studio/Seeed Arduino rpcUnified @ 2.1.3
    seeed-studio/Seeed_Arduino_mbedtls @ 3.0.1
    seeed-studio/Seeed Arduino RTC @ 2.0.0
    bblanchon/ArduinoJson @ 6.17.3
    ```

1. `config.h` ಹೆಡರ್ ಫೈಲ್‌ಗೆ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    const char *SSID = "<SSID>";
    const char *PASSWORD = "<PASSWORD>";
    
    const char *SPEECH_API_KEY = "<API_KEY>";
    const char *SPEECH_LOCATION = "<LOCATION>";
    const char *LANGUAGE = "<LANGUAGE>";

    const char *TOKEN_URL = "https://%s.api.cognitive.microsoft.com/sts/v1.0/issuetoken";
    ```

    `<SSID>` ಮತ್ತು `<PASSWORD>` ಅನ್ನು ನಿಮ್ಮ WiFi ಗಾಗಿ ಸಂಬಂಧಿಸಿದ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಬದಲಾಯಿಸಿ.

    ನಿಮ್ಮ ಸ್ಪೀಚ್ ಸರ್ವೀಸ್ ಸಂಪನ್ಮೂಲದ API ಕೀ ಹೊಂದಿರುವ `<API_KEY>` ಅನ್ನು ಬದಲಾಯಿಸಿ. ಸ್ಪೀಚ್ ಸರ್ವೀಸ್ ಸಂಪನ್ಮೂಲವನ್ನು ಸೃಷ್ಟಿಸಿದಾಗ ಬಳಸಿದ ಸ್ಥಳವನ್ನು `<LOCATION>` ಅನ್ನು ಬದಲಾಯಿಸಿ.

    ನೀವು ಮಾತನಾಡಲಿರುವ ಭಾಷೆಯ ಸ್ಥಳೀಯ ಹೆಸರಿನ ಹಾಗೆ `<LANGUAGE>` ಅನ್ನು ಬದಲಾಯಿಸಿ, ಉದಾಹರಣೆಗೆ English ಗೆ `en-GB`, ಅಥವಾ Cantonese ಗಾಗಿ `zn-HK`. ಬೆಂಬಲಿತ ಭಾಷೆಗಳ ಪಟ್ಟಿಯು ಮತ್ತು ಅವುಗಳ ಸ್ಥಳೀಯ ಹೆಸರುಗಳನ್ನು ನೀವು [Language and voice support documentation on Microsoft docs](https://docs.microsoft.com/azure/cognitive-services/speech-service/language-support?WT.mc_id=academic-17441-jabenn#speech-to-text) ನಲ್ಲಿ ಕಾಣಬಹುದು.

    `TOKEN_URL` ಸ್ಥಿರಾಂಕವು ಸ್ಥಳವನ್ನು ಹೊರತುಪಡಿಸಿ ಟೋಕನ್ ರವಾನಾತೃ URL ಆಗಿದೆ. ನಂತರ ಭರಿತ URL ಪಡೆಯಲು ಸ್ಥಳವನ್ನು ಜೊತೆಗೆ ಸೇರಿಸಲಾಗುತ್ತದೆ.

1. Custom Vision ಗೆ ಸಂಪರ್ಕಿಸುವಂತೆಯೇ, ಟೋಕನ್ ರವಾನಾತೃ ಸೇವೆಗೆ ಸಂಪರ್ಕಿಸಲು HTTPS ಸಂಪರ್ಕವನ್ನು ಉಪಯೋಗಿಸಬೇಕಾಗುತ್ತದೆ. `config.h` ಕೊನೆಯಲ್ಲಿ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    const char *TOKEN_CERTIFICATE =
        "-----BEGIN CERTIFICATE-----\r\n"
        "MIIF8zCCBNugAwIBAgIQAueRcfuAIek/4tmDg0xQwDANBgkqhkiG9w0BAQwFADBh\r\n"
        "MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\r\n"
        "d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\r\n"
        "MjAeFw0yMDA3MjkxMjMwMDBaFw0yNDA2MjcyMzU5NTlaMFkxCzAJBgNVBAYTAlVT\r\n"
        "MR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKjAoBgNVBAMTIU1pY3Jv\r\n"
        "c29mdCBBenVyZSBUTFMgSXNzdWluZyBDQSAwNjCCAiIwDQYJKoZIhvcNAQEBBQAD\r\n"
        "ggIPADCCAgoCggIBALVGARl56bx3KBUSGuPc4H5uoNFkFH4e7pvTCxRi4j/+z+Xb\r\n"
        "wjEz+5CipDOqjx9/jWjskL5dk7PaQkzItidsAAnDCW1leZBOIi68Lff1bjTeZgMY\r\n"
        "iwdRd3Y39b/lcGpiuP2d23W95YHkMMT8IlWosYIX0f4kYb62rphyfnAjYb/4Od99\r\n"
        "ThnhlAxGtfvSbXcBVIKCYfZgqRvV+5lReUnd1aNjRYVzPOoifgSx2fRyy1+pO1Uz\r\n"
        "aMMNnIOE71bVYW0A1hr19w7kOb0KkJXoALTDDj1ukUEDqQuBfBxReL5mXiu1O7WG\r\n"
        "0vltg0VZ/SZzctBsdBlx1BkmWYBW261KZgBivrql5ELTKKd8qgtHcLQA5fl6JB0Q\r\n"
        "gs5XDaWehN86Gps5JW8ArjGtjcWAIP+X8CQaWfaCnuRm6Bk/03PQWhgdi84qwA0s\r\n"
        "sRfFJwHUPTNSnE8EiGVk2frt0u8PG1pwSQsFuNJfcYIHEv1vOzP7uEOuDydsmCjh\r\n"
        "lxuoK2n5/2aVR3BMTu+p4+gl8alXoBycyLmj3J/PUgqD8SL5fTCUegGsdia/Sa60\r\n"
        "N2oV7vQ17wjMN+LXa2rjj/b4ZlZgXVojDmAjDwIRdDUujQu0RVsJqFLMzSIHpp2C\r\n"
        "Zp7mIoLrySay2YYBu7SiNwL95X6He2kS8eefBBHjzwW/9FxGqry57i71c2cDAgMB\r\n"
        "AAGjggGtMIIBqTAdBgNVHQ4EFgQU1cFnOsKjnfR3UltZEjgp5lVou6UwHwYDVR0j\r\n"
        "BBgwFoAUTiJUIBiV5uNu5g/6+rkS7QYXjzkwDgYDVR0PAQH/BAQDAgGGMB0GA1Ud\r\n"
        "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjASBgNVHRMBAf8ECDAGAQH/AgEAMHYG\r\n"
        "CCsGAQUFBwEBBGowaDAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQu\r\n"
        "Y29tMEAGCCsGAQUFBzAChjRodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGln\r\n"
        "aUNlcnRHbG9iYWxSb290RzIuY3J0MHsGA1UdHwR0MHIwN6A1oDOGMWh0dHA6Ly9j\r\n"
        "cmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEdsb2JhbFJvb3RHMi5jcmwwN6A1oDOG\r\n"
        "MWh0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEdsb2JhbFJvb3RHMi5j\r\n"
        "cmwwHQYDVR0gBBYwFDAIBgZngQwBAgEwCAYGZ4EMAQICMBAGCSsGAQQBgjcVAQQD\r\n"
        "AgEAMA0GCSqGSIb3DQEBDAUAA4IBAQB2oWc93fB8esci/8esixj++N22meiGDjgF\r\n"
        "+rA2LUK5IOQOgcUSTGKSqF9lYfAxPjrqPjDCUPHCURv+26ad5P/BYtXtbmtxJWu+\r\n"
        "cS5BhMDPPeG3oPZwXRHBJFAkY4O4AF7RIAAUW6EzDflUoDHKv83zOiPfYGcpHc9s\r\n"
        "kxAInCedk7QSgXvMARjjOqdakor21DTmNIUotxo8kHv5hwRlGhBJwps6fEVi1Bt0\r\n"
        "trpM/3wYxlr473WSPUFZPgP1j519kLpWOJ8z09wxay+Br29irPcBYv0GMXlHqThy\r\n"
        "8y4m/HyTQeI2IMvMrQnwqPpY+rLIXyviI2vLoI+4xKE4Rn38ZZ8m\r\n"
        "-----END CERTIFICATE-----\r\n";
    ```

    ಇದು Custom Vision ಗೆ ಸಂಪರ್ಕಿಸಿದಾಗ ನಿಮ್ಮ ಬಳಕೆ ಮಾಡಿದ ಅದೇ ಪ್ರಮಾಣಪತ್ರ.

1. `main.cpp` ಫೈಲ್顶部ಕ್ಕೆ WiFi ಹೆಡರ್ ಫೈಲ್ ಮತ್ತು config ಹೆಡರ್ ಫೈಲ್ ಇನ್‌ಕ್ಲೂಡ್ ಆಗ하도록 ಸೇರಿಸಿ:

    ```cpp
    #include <rpcWiFi.h>

    #include "config.h"
    ```

1. `main.cpp` ನಲ್ಲಿ `setup` ಫಂಕ್ಷನ್ ಮೀರಿದ ಮೇಲೆ WiFi ಗೆ ಸಂಪರ್ಕಿಸಲು ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    void connectWiFi()
    {
        while (WiFi.status() != WL_CONNECTED)
        {
            Serial.println("Connecting to WiFi..");
            WiFi.begin(SSID, PASSWORD);
            delay(500);
        }
    
        Serial.println("Connected!");
    }
    ```

1. ಸರಣಿ ಸಂಪರ್ಕ ಮಾಡಲ್ಪಟ್ಟ ನಂತರ `setup` ಫಂಕ್ಷನಿನಲ್ಲಿ ಈ ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆ ಮಾಡಿ:

    ```cpp
    connectWiFi();
    ```

1. `src` ಫೋಲ್ಡರ್‌ನಲ್ಲಿ `speech_to_text.h` ಎಂಬ ಹೆಡರ್ ಫೈಲ್ ಹೊಸದಾಗಿ ಸೃಷ್ಠಿಸಿ. ಈ ಹೆಡರ್ ಫೈಲ್ ನಲ್ಲಿ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    #pragma once
    
    #include <Arduino.h>
    #include <ArduinoJson.h>
    #include <HTTPClient.h>
    #include <WiFiClientSecure.h>
    
    #include "config.h"
    #include "mic.h"
    
    class SpeechToText
    {
    public:

    private:

    };

    SpeechToText speechToText;
    ```

    ಇದು HTTP ಸಂಪರ್ಕಕ್ಕೆ ಕೆಲವು ಅವಶ್ಯಕ ಹೆಡರ್ ಫೈಲ್‌ಗಳನ್ನು, ಸಂರಚನೆಯನ್ನು ಮತ್ತು `mic.h` ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ ಮತ್ತು `SpeechToText` ಎಂಬ ಕ್ಲಾಸ್ ಅನ್ನು นิರ\u200dಯಮಿಸುತ್ತದೆ ಹಾಗು ಆ ಕ್ಲಾಸ್ ನ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ನಂತರ ಉಪಯೋಗಿಸಲು ಘೋಷಿಸುತ್ತದೆ.

1. ಈ ಕ್ಲಾಸ್ ನ `private` ವಿಭಾಗದಲ್ಲಿ ಕೆಳಗಿನ 2 ಕ್ಷೇತ್ರಗಳನ್ನು ಸೇರಿಸಿ:

    ```cpp
    WiFiClientSecure _token_client;
    String _access_token;
    ```

    `_token_client` ಎಂದರೆ HTTPS ಬಳಸಿ WiFi Client ಆಗಿದ್ದು, ಪ್ರವೇಶ ಟೋಕನ್ ಪಡೆಯಲು ಉಪಯೋಗಿಸಲಾಗುತ್ತದೆ. ಆ ಟೋಕನ್ ಅನ್ನು ನಂತರ `_access_token` ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

1. `private` ವಿಭಾಗದಲ್ಲಿ ಈ ವಿಧಾನವನ್ನು ಸೇರಿಸಿ:

    ```cpp
    String getAccessToken()
    {
        char url[128];
        sprintf(url, TOKEN_URL, SPEECH_LOCATION);
    
        HTTPClient httpClient;
        httpClient.begin(_token_client, url);
    
        httpClient.addHeader("Ocp-Apim-Subscription-Key", SPEECH_API_KEY);
        int httpResultCode = httpClient.POST("{}");
    
        if (httpResultCode != 200)
        {
            Serial.println("Error getting access token, trying again...");
            delay(10000);
            return getAccessToken();
        }
    
        Serial.println("Got access token.");
        String result = httpClient.getString();
    
        httpClient.end();
    
        return result;
    }
    ```

    ಈ ಕೋಡ್ ಸ್ಪೀಚ್ ಸಂಪನ್ಮೂಲದ ಸ್ಥಳ ಬಳಸಿ ಟೋಕನ್ ರವಾನಾತೃ API ಗಾಗಿ URL ಅನ್ನು ರಚಿಸುತ್ತದೆ. ನಂತರ WiFi ಕ್ಲಯಂಟ್ ಅನ್ನು ಟೋಕನ್ ಎಂಡ್‌ಪಾಯಿಂಟ್ ಪ್ರಮಾಣಪತ್ರದೊಂದಿಗೆ ಹೊಂದಿಸಿ HTTPClient ರಚಿಸುತ್ತದೆ. API ಕೀ ಅನ್ನು ಕರೆಗಾಗಿ ಹೆಡರ್ ಆಗಿ ಸಿದ್ಧಪಡಿಸುತ್ತದೆ. ನಂತರ POST ವಿನಂತಿ ಮಾಡಿ ಪ್ರಮಾಣಪತ್ರ ಪಡೆಯುವ ತನಕ ಮರುಪ್ರಯತ್ನ ಮಾಡುತ್ತದೆ. ಕೊನೆಗೆ ಪ್ರವೇಶ ಟೋಕನ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

1. `public` ವಿಭಾಗದಲ್ಲಿ, ಪ್ರವೇಶ ಟೋಕನ್ ಪಡೆಯಲು ವಿಧಾನ ಒಂದು ಸೇರಿಸಿ. ಮುಂದಿನ ಪಾಠಗಳಲ್ಲಿ ಇದು ಪಠ್ಯವನ್ನು ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸಲು ಬೇಕಾಗುತ್ತದೆ.

    ```cpp
    String AccessToken()
    {
        return _access_token;
    }
    ```

1. `public` ವಿಭಾಗದಲ್ಲಿ, ಟೋಕನ್ ಕ್ಲಯಂಟ್ ಅನ್ನು ಸಂರಚಿಸುವ `init` ವಿಧಾನ ಸೇರಿಸಿ:

    ```cpp
    void init()
    {
        _token_client.setCACert(TOKEN_CERTIFICATE);
        _access_token = getAccessToken();
    }
    ```

    ಇದು WiFi ಕ್ಲಯಂಟ್ ಮೇಲೆ ಪ್ರಮಾಣಪತ್ರವನ್ನು ಸೆಟ್ ಮಾಡಿ, ನಂತರ ಪ್ರವೇಶ ಟೋಕನ್ ಪಡೆಯುತ್ತದೆ.

1. `main.cpp` ನಲ್ಲಿ ಈ ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಇನ್‌ಕ್ಲೂಡ್ ನಿರ್ದೇಶನಗಳಿಗೆ ಸೇರಿಸಿ:

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

1. `setup` ಫಂಕ್ಷನ್ ಕೊನೆಯಲ್ಲಿ `mic.init` ನಂತರ ಮತ್ತು `Ready` ಸರಣಿ মনಿಟರ್ ಗೆ ಬರೆಯುವ ಮುನ್ನ `SpeechToText` ಕ್ಲಾಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ:

    ```cpp
    speechToText.init();
    ```

### ಕಾರ್ಯ - ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯಿಂದ ಧ್ವನಿಯನ್ನು ಓದಿ

1. ಈ ಪಾಠದ ಮೊದಲು ಭಾಗದಲ್ಲಿ, ಧ್ವನಿಯನ್ನು ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯಲ್ಲಿ ದಾಖಲಿಸಲಾಗಿತ್ತು. ಈ ಧ್ವನಿಯನ್ನು Speech Services REST API ಗೆ ಕಳುಹಿಸಬೇಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದನ್ನು ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯಿಂದ ಓದಬೇಕು. ಅದನ್ನು ಸ್ಮರಣೆ ಎಂಬ ಬಫರ್ ಗೆ ತುಂಬಲಾಗುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಅದು ಬಹಳ ದೊಡ್ಡದು. REST ಕಾಲ್ ಮಾಡುವ `HTTPClient` ಕ್ಲಾಸ್ ಡೇಟಾವನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡಬಹುದು, ಅಂದರೆ Arduino Stream - ಯಾವುದು ಸಣ್ಣ ತುಂಡುಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಓದಿ ಅದನ್ನು ಒಂದು ಸಮಯಕ್ಕೆ ಒಂದು ತುಂಡಾಗಿ ವಿನಂತಿಯ ಭಾಗವಾಗಿ ಕಳುಹಿಸುತ್ತದೆ. ಪ್ರತಿ ಬಾರಿ ನೀವು ಸ್ಟ್ರೀಮ್ ಮೇಲೆ `read` ಅನ್ನು ಕರೆ ಮಾಡಿದಾಗ ಅದು ಮುಂದಿನ ಡೇಟಾ ಬಾಕ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯಿಂದ ಓದುವ Arduino ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಸೃಷ್ಠಿಸಿ. `src` ಫೋಲ್ಡರ್ ನಲ್ಲಿ `flash_stream.h` ಎಂಬ ಹೊಸ ಫೈಲ್ ಸೃಷ್ಟಿಸಿ, ಮತ್ತು ಅದು ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    #pragma once
    
    #include <Arduino.h>
    #include <HTTPClient.h>
    #include <sfud.h>

    #include "config.h"
    
    class FlashStream : public Stream
    {
    public:
        virtual size_t write(uint8_t val)
        {    
        }
    
        virtual int available()
        {
        }
    
        virtual int read()
        {
        }
    
        virtual int peek()
        {
        }
    private:
    
    };
    ```

    ಇದು Arduino `Stream` ಕ್ಲಾಸ್ ನಿಂದ ವಂಶಾನುಕ್ರಮಣ ಮಾಡುವ `FlashStream` ಕ್ಲಾಸ್ ಅನ್ನು ಘೋಷಿಸುತ್ತದೆ. ಇದು ಒಂದು ಅವ್ಯವಸ್ಥಿತ ಕ್ಲಾಸ್ ಆಗಿದ್ದು- derived ಕ್ಲಾಸ್ ಗಳಿಗೆ ಕೆಲವು ವಿಧಾನಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ ಇದಕ್ಕೆ ಮುಂಚೆ ಕ್ಲಾಸ್ ಅನ್ನು ಉದ್ಘಾಟಿಸಲು, ಮತ್ತು ಆ ವಿಧಾನಗಳು ಈ ಕ್ಲಾಸ್ ನಲ್ಲಿ ನಿರ್ಧರಿಸಲಾಗಿದೆ.

    ✅ Arduino Stream ಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು ಓದಲು [Arduino Stream documentation](https://www.arduino.cc/reference/en/language/functions/communication/stream/) ತಾಣವನ್ನು ನೋಡಿ

1. `private` ವಿಭಾಗದಲ್ಲಿ ಕೆಳಗಿನ ಕ್ಷೇತ್ರಗಳನ್ನು ಸೇರಿಸಿ:

    ```cpp
    size_t _pos;
    size_t _flash_address;
    const sfud_flash *_flash;

    byte _buffer[HTTP_TCP_BUFFER_SIZE];
    ```

    ಇದು ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯಿಂದ ಓದಿದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ತಾತ್ಕಾಲಿಕ ಬಫರ್ ಮತ್ತು ಬಫರ್ ಅನ್ನು ಓದುತ್ತಿರುವಾಗ ಪ್ರಸ್ತುತ ಸ್ಥಾನಮಾನ, ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯಿಂದ ಓದಲು ಪ್ರಸ್ತುತ ವಿಳಾಸ ಮತ್ತು ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿ ಸಾಧನವನ್ನು ಸಂಗ್ರಹಿಸುವ ಕ್ಷೇತ್ರಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.

1. `private` ವಿಭಾಗದಲ್ಲಿ ಕೆಳಗಿನ ವಿಧಾನವನ್ನು ಸೇರಿಸಿ:

    ```cpp
    void populateBuffer()
    {
        sfud_read(_flash, _flash_address, HTTP_TCP_BUFFER_SIZE, _buffer);
        _flash_address += HTTP_TCP_BUFFER_SIZE;
        _pos = 0;
    }
    ```

    ಈ ಕೋಡ್ ಪ್ರಸ್ತುತ ವಿಳಾಸದಲ್ಲಿ ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯಿಂದ ಓದುತ್ತದೆ ಮತ್ತು ಡೇಟಾವನ್ನು ಬಫರ್ ನಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ನಂತರ ವಿಳಾಸವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಮುಂದಿನ ಕಾಲ್ ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯ ಮುಂದಿನ ತುಂಡನ್ನು ಓದುವಂತೆ ಮಾಡುತ್ತದೆ. ಬಫರ್ ಗಾತ್ರವನ್ನು REST API ಗೆ ಒಂದೇ ಸಮಯದಲ್ಲಿ HTTPClient ಕಳುಹಿಸುವ ದೊಡ್ಡ ಮಗುಟಿನ ಗಾತ್ರ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಧರಿಸಲಾಗಿದೆ.

    > 💁 ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿಯನ್ನು ಅಳಿಸುವುದು ಗ್ರೇನ್ ಗಾತ್ರ ಬಳಸಿ ಮಾಡಬೇಕು, ಓದುವುದು ಹಾಗಾಗಬೇಕು ಅನಿಸುವುದು ಅಲ್ಲ.

1. ಈ ಕ್ಲಾಸ್ ನ `public` ವಿಭಾಗದಲ್ಲಿ ನಿರ್ಮಾಪಕ (constructor) ಸೇರಿಸಿ:

    ```cpp
    FlashStream()
    {
        _pos = 0;
        _flash_address = 0;
        _flash = sfud_get_device_table() + 0;
        
        populateBuffer();
    }
    ```

    ಈ ನಿರ್ಮಾಪಕ ಎಲ್ಲಾ ಕ್ಷೇತ್ರಗಳನ್ನು ಸೂಚಿಸಿದಂತೆ ಆರಂಭಿಸಿ ಫ್ಲ್ಯಾಶ್ ಮೆಮೊರಿ ಬ್ಲಾಕ್ ನ ಆರಂಭದಿಂದ ಓದಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಬಫರ್ ಗೆ ಮೊದಲ ತುಂಡು ಡೇಟಾ ಲೋಡ್ ಮಾಡುತ್ತದೆ.

1. `write` ವಿಧಾನವನ್ನು ಜಾರಿಮಾಡಿ (implement) ಮಾಡಿ. ಈ ಸ್ಟ್ರೀಮ್ ಮಹತ್ವಪೂರ್ಣವಾಗಿ ಡೇಟಾವನ್ನು ಓದುತ್ತದೆ, ಆದ್ದರಿಂದ ಇದು ಏನೂ ಮಾಡದೆ 0 ನ್ನು ಹಿಂತಿರುಗಿಸಬಹುದು:

    ```cpp
    virtual size_t write(uint8_t val)
    {
        return 0;
    }
    ```

1. `peek` ವಿಧಾನವನ್ನು ಜಾರಿಮಾಡಿ. ಇದು ಪ್ರಸ್ತುತ ಸ್ಥಾನದಿಂದ ಡೇಟಾವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಆದರೆ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಮುಂದೆ ಸಾಗಿಸುವುದಿಲ್ಲ. ಇವನ್ನು ಹಲವಾರು ಬಾರಿ ಕರೆ ಮಾಡಿದರೂ ಅನೇಕ ಓದಿಲ್ಲದಿದ್ದರೆ ಒಂದೇ ಡೇಟಾ ಹಿಂತಿರುಗುತ್ತದೆ.

    ```cpp
    virtual int peek()
    {
        return _buffer[_pos];
    }
    ```

1. `available` ವಿಧಾನವನ್ನು ಜಾರಿಮಾಡಿ. ಇದು ಸ್ಟ್ರೀಮ್ ನಲ್ಲಿ ಓದಬಹುದಾದ ಬೈಟ್ ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಥವಾ ಸ್ಟ್ರೀಮ್ ಮುಗಿದಿದ್ದರೆ -1 ಅನ್ನು ನೀಡುತ್ತದೆ. ಈ ಕ್ಲಾಸ್ ಗಾಗಿ ಗರಿಷ್ಠ ಲಭ್ಯವಿರುವ ಬೆಳವಣಿಗೆ HTTPClient ನ ಮಗುಟಿನ ಗಾತ್ರವನ್ನು ಮೀರದು. HTTPClient ಉಪಯೋಗಿಸಿದಾಗ ಈ ವಿಧಾನವನ್ನು ಕರೆದು ಲಭ್ಯವಿರುವ ಡೇಟಾವನ್ನು ಪರಿಶೀಲಿಸಿ, ನಂತರ REST API ಗೆ ಕಳುಹಿಸಲು ಆಷ್ಟು ಡೇಟಾವನ್ನು ವಿನಂತಿಸುತ್ತದೆ. ಹೆಚ್ಚು ಇದ್ದರೆ ಮಗುಟಿನ ಗಾತ್ರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಕಡಿಮೆ ಇದ್ದರೆ ಲಭ್ಯವಿರುವಷ್ಟು ಬಿತ್ತರಿಸುತ್ತದೆ. ಎಲ್ಲ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಆದ ಮೇಲೆ -1 ಹಿಂತಿರುಗುತ್ತದೆ.

    ```cpp
    virtual int available()
    {
        int remaining = BUFFER_SIZE - ((_flash_address - HTTP_TCP_BUFFER_SIZE) + _pos);
        int bytes_available = min(HTTP_TCP_BUFFER_SIZE, remaining);

        if (bytes_available == 0)
        {
            bytes_available = -1;
        }

        return bytes_available;
    }
    ```

1. `read` ವಿಧಾನವನ್ನು ಜಾರಿಮಾಡಿ. ಇದು ಮುಂದಿನ ಬಫರ್ ನ ಬೈಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಮತ್ತು ಸ್ಥಾನವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಸ್ಥಾನ ಬಫರ್ ಗಾತ್ರ ಮೊದಲು ಮೀರಿದರೆ, ಮುಂದೆ ಫ್ಲ್ಯಾಶ್ ಟುಂಡನ್ನು ಬಫರ್ ಗೆ ಲೋಡ್ ಮಾಡಿ ಸ್ಥಾನವನ್ನು ಪುನಃ ಹೊಂದಿಸುತ್ತದೆ.

    ```cpp
    virtual int read()
    {
        int retVal = _buffer[_pos++];

        if (_pos == HTTP_TCP_BUFFER_SIZE)
        {
            populateBuffer();
        }

        return retVal;
    }
    ```

1. `speech_to_text.h` ಹೆಡರ್ ಫೈಲ್‌ನಲ್ಲಿ ಈ ಹೊಸ ಹೆಡರ್ ಫೈಲ್ ರಿಂದ ಇನ್‌ಕ್ಲೂಡ್ ನಿರ್ದೇಶನ ಸೇರಿಸಿ:

    ```cpp
    #include "flash_stream.h"
    ```

### ಕಾರ್ಯ - ಧ್ವನಿಯನ್ನು ಪಠ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿ

1. ಧ್ವನಿಯನ್ನು ಪಠ್ಯಕ್ಕೆ speech service REST API ಮೂಲಕ ಕಳುಹಿಸುವ ಮೂಲಕ ಪರಿವರ್ತಿಸಬಹುದು. ಈ REST API ಗೆ ಟೋಕನ್ ರವಾನಾತೃಗೆ ಇರುವ ಪ್ರಮಾಣಪತ್ರಕ್ಕಿಂತ ವಿಭಿನ್ನ ಪ್ರಮಾಣಪತ್ರವಿದೆ, ಆದ್ದರಿಂದ `config.h` ಹೆಡರ್ ಫೈಲ್‌ಗೆ ಈ ಪ್ರಮಾಣಪತ್ರವನ್ನು ಸಂಜ್ಜಿಸುತ್ತಿರುವ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    const char *SPEECH_CERTIFICATE =
        "-----BEGIN CERTIFICATE-----\r\n"
        "MIIF8zCCBNugAwIBAgIQCq+mxcpjxFFB6jvh98dTFzANBgkqhkiG9w0BAQwFADBh\r\n"
        "MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\r\n"
        "d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH\r\n"
        "MjAeFw0yMDA3MjkxMjMwMDBaFw0yNDA2MjcyMzU5NTlaMFkxCzAJBgNVBAYTAlVT\r\n"
        "MR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKjAoBgNVBAMTIU1pY3Jv\r\n"
        "c29mdCBBenVyZSBUTFMgSXNzdWluZyBDQSAwMTCCAiIwDQYJKoZIhvcNAQEBBQAD\r\n"
        "ggIPADCCAgoCggIBAMedcDrkXufP7pxVm1FHLDNA9IjwHaMoaY8arqqZ4Gff4xyr\r\n"
        "RygnavXL7g12MPAx8Q6Dd9hfBzrfWxkF0Br2wIvlvkzW01naNVSkHp+OS3hL3W6n\r\n"
        "l/jYvZnVeJXjtsKYcXIf/6WtspcF5awlQ9LZJcjwaH7KoZuK+THpXCMtzD8XNVdm\r\n"
        "GW/JI0C/7U/E7evXn9XDio8SYkGSM63aLO5BtLCv092+1d4GGBSQYolRq+7Pd1kR\r\n"
        "EkWBPm0ywZ2Vb8GIS5DLrjelEkBnKCyy3B0yQud9dpVsiUeE7F5sY8Me96WVxQcb\r\n"
        "OyYdEY/j/9UpDlOG+vA+YgOvBhkKEjiqygVpP8EZoMMijephzg43b5Qi9r5UrvYo\r\n"
        "o19oR/8pf4HJNDPF0/FJwFVMW8PmCBLGstin3NE1+NeWTkGt0TzpHjgKyfaDP2tO\r\n"
        "4bCk1G7pP2kDFT7SYfc8xbgCkFQ2UCEXsaH/f5YmpLn4YPiNFCeeIida7xnfTvc4\r\n"
        "7IxyVccHHq1FzGygOqemrxEETKh8hvDR6eBdrBwmCHVgZrnAqnn93JtGyPLi6+cj\r\n"
        "WGVGtMZHwzVvX1HvSFG771sskcEjJxiQNQDQRWHEh3NxvNb7kFlAXnVdRkkvhjpR\r\n"
        "GchFhTAzqmwltdWhWDEyCMKC2x/mSZvZtlZGY+g37Y72qHzidwtyW7rBetZJAgMB\r\n"
        "AAGjggGtMIIBqTAdBgNVHQ4EFgQUDyBd16FXlduSzyvQx8J3BM5ygHYwHwYDVR0j\r\n"
        "BBgwFoAUTiJUIBiV5uNu5g/6+rkS7QYXjzkwDgYDVR0PAQH/BAQDAgGGMB0GA1Ud\r\n"
        "JQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjASBgNVHRMBAf8ECDAGAQH/AgEAMHYG\r\n"
        "CCsGAQUFBwEBBGowaDAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQu\r\n"
        "Y29tMEAGCCsGAQUFBzAChjRodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGln\r\n"
        "aUNlcnRHbG9iYWxSb290RzIuY3J0MHsGA1UdHwR0MHIwN6A1oDOGMWh0dHA6Ly9j\r\n"
        "cmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEdsb2JhbFJvb3RHMi5jcmwwN6A1oDOG\r\n"
        "MWh0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEdsb2JhbFJvb3RHMi5j\r\n"
        "cmwwHQYDVR0gBBYwFDAIBgZngQwBAgEwCAYGZ4EMAQICMBAGCSsGAQQBgjcVAQQD\r\n"
        "AgEAMA0GCSqGSIb3DQEBDAUAA4IBAQAlFvNh7QgXVLAZSsNR2XRmIn9iS8OHFCBA\r\n"
        "WxKJoi8YYQafpMTkMqeuzoL3HWb1pYEipsDkhiMnrpfeYZEA7Lz7yqEEtfgHcEBs\r\n"
        "K9KcStQGGZRfmWU07hPXHnFz+5gTXqzCE2PBMlRgVUYJiA25mJPXfB00gDvGhtYa\r\n"
        "+mENwM9Bq1B9YYLyLjRtUz8cyGsdyTIG/bBM/Q9jcV8JGqMU/UjAdh1pFyTnnHEl\r\n"
        "Y59Npi7F87ZqYYJEHJM2LGD+le8VsHjgeWX2CJQko7klXvcizuZvUEDTjHaQcs2J\r\n"
        "+kPgfyMIOY1DMJ21NxOJ2xPRC/wAh/hzSBRVtoAnyuxtkZ4VjIOh\r\n"
        "-----END CERTIFICATE-----\r\n";
    ```

1. ಈ ಫೈಲ್ ಗೆ ಸ್ಥಳ ಇಲ್ಲದೆ ಸ್ಪೀಚ್ URL ಇಂದ ಸ್ಥಿರಾಂಕ ಸೇರಿಸಿ. ನಂತರ ಸ್ಥಳ ಮತ್ತು ಭಾಷೆಯನ್ನು ಬಸಿಯಾಗಿ ಪೂರ್ಣ URL ಪಡೆಯಲಾಗುತ್ತದೆ.

    ```cpp
    const char *SPEECH_URL = "https://%s.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=%s";
    ```

1. `speech_to_text.h` ಹೆಡರ್ ಫೈಲ್ ನಲ್ಲಿ `SpeechToText` ಕ್ಲಾಸ್ ನ `private` ವಿಭಾಗದಲ್ಲಿ ಈ ಸ್ಪೀಚ್ ಪ್ರಮಾಣಪತ್ರ ಬಳಸಿ WiFi Client ನ ಕ್ಷೇತ್ರ ಘೋಷಿಸಿ:

    ```cpp
    WiFiClientSecure _speech_client;
    ```

1. `init` ವಿಧಾನದಲ್ಲಿ ಈ WiFi Client ಮೇಲೆ ಪ್ರಮಾಣಪತ್ರವನ್ನು ಹೆಚ್ಚಿಸಿ:

    ```cpp
    _speech_client.setCACert(SPEECH_CERTIFICATE);
    ```

1. `SpeechToText` ಕ್ಲಾಸ್ ನ `public` ವಿಭಾಗದಲ್ಲಿ ಧ್ವನಿಯನ್ನು ಪಠ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲು ಈ ಕೆಳಗಿನ ವಿಧಾನವನ್ನು ಸೇರಿಸಿ:

    ```cpp
    String convertSpeechToText()
    {
        
    }
    ```

1. ಈ ವಿಧಾನದಲ್ಲಿ WiFi Client ಬಳಸಿ HTTPClient ರಚಿಸಿ, ಸ್ಪೀಚ್ ಪ್ರಮಾಣಪತ್ರ ಮತ್ತು ಸ್ಥಳ ಮತ್ತು ಭಾಷೆಯೊಂದಿಗೆ ಹೊಂದಿಸಲಾದ ಸ್ಪೀಚ್ URL ಉಪಯೋಗಿಸಿ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    char url[128];
    sprintf(url, SPEECH_URL, SPEECH_LOCATION, LANGUAGE);

    HTTPClient httpClient;
    httpClient.begin(_speech_client, url);
    ```

1. ಕೆಲವು ಹೆಡರ್ ಗಳು ಸಂಪರ್ಕದಲ್ಲಿ ಸಿದ್ಧಪಡಿಸಬೇಕಾಗಿವೆ:

    ```cpp
    httpClient.addHeader("Authorization", String("Bearer ") + _access_token);
    httpClient.addHeader("Content-Type", String("audio/wav; codecs=audio/pcm; samplerate=") + String(RATE));
    httpClient.addHeader("Accept", "application/json;text/xml");
    ```

    ಇದು ಪ್ರವೇಶ ಟೋಕನ್ ಬಳಸಿ ಪ್ರಮಾಣೀಕರಣ ಹೆಡರ್, ಕೇಳಿದ ನುಡಿವಿನ ಮಾದರಿ ಹಾಗು ಮಾದರಿ ದರ ಬಳಸಿ ಧ್ವನಿ ಫಾರ್ಮ್ಯಾಟ್ ಹೆಡರ್, ಮತ್ತು ಫಲಿತಾಂಶ JSON ಆಗಿದ್ದುಂಬ ಅವಕಾಶ ಸೆಟ್ ಮಾಡುತ್ತದೆ.

1. ಅದಕ್ಕೆ ನಂತರ REST API ಕರೆ ಮಾಡಲು ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:

    ```cpp
    Serial.println("Sending speech...");

    FlashStream stream;
    int httpResponseCode = httpClient.sendRequest("POST", &stream, BUFFER_SIZE);

    Serial.println("Speech sent!");
    ```

    ಇದು `FlashStream` ಸೃಷ್ಟಿಸಿ REST API ಗೆ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಮಾಡಲು ಉಪಯೋಗಿಸುತ್ತದೆ.

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

    ```cpp
    String text = "";

    if (httpResponseCode == 200)
    {
        String result = httpClient.getString();
        Serial.println(result);

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

        JsonObject obj = doc.as<JsonObject>();
        text = obj["DisplayText"].as<String>();
    }
    else if (httpResponseCode == 401)
    {
        Serial.println("Access token expired, trying again with a new token");
        _access_token = getAccessToken();
        return convertSpeechToText();
    }
    else
    {
        Serial.print("Failed to convert text to speech - error ");
        Serial.println(httpResponseCode);
    }
    ```

    ಈ ಕೋಡ್ ಪ್ರತಿಕ್ರಿಯಾ ಕೋಡ್ ಪರಿಶೀಲಿಸುತ್ತದೆ.

    200 ಎಂದರೆ ಯಶಸ್ಸಿನ ಕೋಡ್ ಆಗಿದ್ದು, ಫಲಿತಾಂಶವನ್ನು JSON ರೀತಿ ಡಿಕೋಡ್ ಮಾಡಿ, `DisplayText` ಗುಣಲಕ್ಷಣವನ್ನು `text` ವ್ಯತ್ಯಯದಲ್ಲಿ ಸೆಟ್ ಮಾಡುತ್ತದೆ. ಇದು ಧ್ವನಿಯ ಪಠ್ಯ ಆಕಾರ ಕೊಡುವ ಆಸ್ಥಿತ್ವವಾಗಿದ್ದು.

    401 ಪ್ರತಿಕ್ರಿಯಾ ಕೋಡ್ ಇದ್ದರೆ, ಪ್ರವೇಶ ಟೋಕನ್ ಅವಧಿ ಮುಗಿದಿದೆ (ಈ ಟೋಕನ್ಗಳು 10 ನಿಮಿಷಗಳಷ್ಟೇ ಇರುತ್ತವೆ). ಇದಕ್ಕೆ ಹೊಸ ಪ್ರವೇಶ ಟೋಕನ್ ಕೇಳಲಾಗುತ್ತದೆ ಮತ್ತು ಮತ್ತೆ ಕರೆ ಮಾಡಲಾಗುತ್ತದೆ.

    ಇಲ್ಲದಿದ್ದರೆ, ಸರಣಿ ಮ್ಯಾನಿಟರ್ ಗೆ ದೋಷ ಸಂದೇಶ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು `text` ಖಾಲಿ ಇಡಲಾಗುತ್ತದೆ.

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

    ```cpp
    httpClient.end();

    return text;
    ```

1. `main.cpp` ನಲ್ಲಿ `processAudio` ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಹೊಸ `convertSpeechToText` ವಿಧಾನವನ್ನು ಕರೆ ಮಾಡಿ, ನಂತರ ಧ್ವನಿಯನ್ನು ಸರಣಿ ಮ್ಯಾನಿಟರ್ ಗೆ ಲಾಗ್ ಮಾಡಿ:

    ```cpp
    String text = speechToText.convertSpeechToText();
    Serial.println(text);
    ```

1. ಈ ಕೋಡ್ ಅನ್ನು ಕಟ್ಟಿಸಿ, ನಿಮ್ಮ Wio Terminal ಗೆ ಅಪ್ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಸರಣಿ ಮ್ಯಾನಿಟರ್ ಮೂಲಕ ಪರೀಕ್ಷಿಸಿ. ಸರಣಿ ಮ್ಯಾನಿಟರ್ ನಲ್ಲಿ `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.
    ```

> 💁 ಈ ಕೋಡ್ ಅನ್ನು [code-speech-to-text/wio-terminal](../../../../../6-consumer/lessons/1-speech-recognition/code-speech-to-text/wio-terminal) ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ನೀವು ಕಾಣಬಹುದು.

😀 ನಿಮ್ಮ ಸ್ಪೀಚ್ ಟು ಟೆಕ್ಸ್ಟ್ ಪ್ರೋಗ್ರಾಂ ಯಶಸ್ವಿಯಾಯಿತು!

---

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