# 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_KEY>` స్థానంలో మీ స్పీచ్ సర్వీస్ రిసోర్స్‌కి సంబంధించిన API కీని చేర్చండి. మీరు స్పీచ్ సర్వీస్ రిసోర్స్ సృష్టించినప్పుడు ఉపయోగించిన లొకేషన్‌ను `<LOCATION>` స్థానంలో చేర్చండి.

    మీరు మాట్లాడబోయే భాషకి సంబంధించిన లోకల్ నేమ్‌తో `<LANGUAGE>`ని భర్తీ చేయండి, ఉదాహరణకు ఇంగ్లీష్‌కి `en-GB`, లేదా కాంటోనీస్‌కు `zn-HK`. మైక్రోసాఫ్ట్ డాక్స్‌లో [భాష మరియు స్వరం మద్దతు డాక్యుమెంటేషన్](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.h హెడర్ ఫైల్ కోసం include జోడించండి:

    ```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` అనే క్లాస్‌ను డిఫైన్ చేసి ఆ క్లాస్ ఇన్స్టాన్స్‌ను డిక్లేర్ చేస్తుంది.

1. ఈ క్లాస్ యొక్క `private` సెక్షన్‌కు ఈ క్రింది 2 ఫీల్డ్స్ జోడించండి:

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

    `_token_client` అనేది HTTPS ఉపయోగించే WiFi క్లయింట్, ఇది యాక్సెస్ టోకెన్ పొందడానికి వాడబడుతుంది. టోకెన్ తర్వాత `_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 నిర్మిస్తుంది. తరువాత ఒక `HTTPClient` క్రియేట్ చేసి, WiFi క్లయింట్‌తో కూడా సెట్ చేస్తుంది, టోకెన్ ఎండ్‌పాయింట్ సర్టిఫికేట్‌తో. 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`లో ఈ కొత్త హెడర్ ఫైల్ కోసం include డైరెక్టివ్ జోడించండి:

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

1. `setup` ఫంక్షన్ చివర, `mic.init` కాల్ తరువాత, `Ready` సీరియల్ మానిటర్‌కు రాయబడే ముందు, `SpeechToText` క్లాస్ ఇనిషియలైజ్ చేయండి:

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

### టాస్క్ - ఫ్లాష్ మెమరీ నుండి ఆడియో చదవండి

1. ఈ పాఠం ముందు భాగంలో ఆడియోను ఫ్లాష్ మెమరీకి రికార్డ్ చేశాం. ఆ ఆడియో స్పీచ్ సర్వీస్ REST APIకి పంపాలి, కాబట్టి ఫ్లాష్ మెమరీ నుండి ఆవు చదవాలి. అది బఫర్‌లో లోడ్ చేయలేం ఎందుకంటే చాలా పెద్దది. REST కాల్స్ చేసే `HTTPClient` క్లాస్ ఆర్డునో స్ట్రీమ్ ఉపయోగించి డేటాను చిన్న చిన్న బ్లాకులుగా పక్కనపక్కన పంపగలదు. ప్రతి సారి మీరు స్ట్రీమ్‌పై `read` పిలిస్తే తదుపరి డేటా బ్లాక్ వస్తుంది. అర్డునో స్ట్రీమ్‌ను క్రియేట్ చేసి ఫ్లాష్ మెమరీ నుండి చదవగలదు. `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:
    
    };
    ```

    ఇది అర్డునో `Stream` క్లాస్‌ నుండి వంశపారంపర్యంగా వచ్చిన `FlashStream` క్లాస్‌ను డిక్లేర్ చేస్తుంది. ఇది ఒక అభేద్య క్లాస్ - ఈ క్లాస్ ఇన్స్టాన్స్ చేయడానికి derived క్లాస్‌లు కొన్ని మెథడ్‌లు నిర్వచించాలి. అవి ఈ క్లాస్‌లో నిర్వచించబడ్డాయి.

    ✅ అర్డునో స్ట్రీమ్స్ పై మరింత చదవండి [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` సెక్షన్‌లో కన్‌స్ట్రక్టర్ జోడించండి:

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

    ఈ కన్‌స్ట్రక్టర్ అన్ని ఫీల్డ్స్‌ను స్టార్ట్‌లో ప్రారంభించి మొదటి డేటా చంక్‌ను బఫర్‌లో లోడ్ చేస్తుంది.

1. `write` మెథడ్‌ని ఇంప్లిమెంట్ చేయండి. ఈ స్ట్రీమ్ కేవలం చదివిస్తుంది కాబట్టి ఇది ఎలాంటి పనీ చేయకుండా 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` హెడర్ ఫైల్‌లో ఈ కొత్త హెడర్ ఫైల్ కోసం include డైరెక్టివ్ జోడించండి:

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

### టాస్క్ - స్పీచ్‌ని టెక్స్ట్‌గా మార్చండి

1. స్పీచ్ స్పీచ్ సర్వీస్ 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 క్లయింట్ కోసం ఫీల్డ్ డిఫైన్ చేయండి:

    ```cpp
    WiFiClientSecure _speech_client;
    ```

1. `init` మెథడ్‌లో ఈ WiFi క్లయింట్ మీద సర్టిఫికేట్ సెట్ చేయండి:

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

1. స్పీచ్‌ను టెక్స్ట్‌గా మార్చడానికి `SpeechToText` క్లాస్ యొక్క `public` సెక్షన్‌లో క్రింది కోడ్ జోడించండి:

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

1. ఈ మెథడ్‌లో WiFi క్లయింట్‌ను స్పీచ్ సర్టిఫికేట్‌తో సెట్ చేసి, లొకేషన్, భాషతో పూర్తి స్పీచ్ URLని ఉపయోగించి HTTP క్లయింట్ క్రియేట్ చేయడానికి ఈ క్రింది కోడ్ జోడించండి:

    ```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. ఈ మెథడ్ చివర HTTP క్లయింట్ క్లోజ్ చేసి `text`ని రిటర్న్ చేయడానికి క్రింది కోడ్ జోడించండి:

    ```cpp
    httpClient.end();

    return text;
    ```

1. `main.cpp`లో ఈ కొత్త `convertSpeechToText` మెథడ్‌ను `processAudio`లో పిలిచి, స్పీచ్‌ని సీరియల్ మానిటర్‌లో లాగ్ చేయండి:

    ```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 -->