IoT-For-Beginners/translations/te/6-consumer/lessons/1-speech-recognition/wio-terminal-speech-to-text.md

Speech to text - Wio Terminal

ఈ పాఠం భాగంలో, మీరు స్పీచ్ సర్వీస్‌ను ఉపయోగించి క్యాప్చర్ చేసిన ఆడియోలోని మాటలను టెక్స్ట్‌గా మార్చడానికి కోడ్ రాస్తారు.

ఆడియోను స్పీచ్ సర్వీస్‌కు పంపండి

ఆడియోను REST API ద్వారా స్పీచ్ సర్వీస్‌కు పంపవచ్చు. స్పీచ్ సర్వీస్‌ను ఉపయోగించడానికి, మొదట మీరు ఒక యాక్సెస్ టోకెన్‌ను అభ్యర్థించాలి, ఆపై ఆ టోకెన్ ఉపయోగించి REST APIని యాక్సెస్ చేయాలి. ఈ యాక్సెస్ టోకెన్లు 10 నిమిషాల తర్వాత గడువు ముగుస్తాయి, కాబట్టి మీ కోడ్ వాటిని ఎప్పటికప్పుడు అభ్యర్థించాలి కాబట్టి అవి ఎప్పుడూ తాజా ఉంటాయి.

టాస్క్ - యాక్సెస్ టోకెన్ పొందండి

1. smart-timer ప్రాజెక్ట్ ఇప్పటికే తెరుచుకోనిదైతే తెరవండి.

2. WiFi ను యాక్సెస్ చేయడానికి మరియు JSONను హ్యాండిల్ చేయడానికి platformio.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
   

3. config.h హెడర్ ఫైల్‌లో ఈ క్రింది కోడ్‌ని జోడించండి:

   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. మైక్రోసాఫ్ట్ డాక్స్‌లో భాష మరియు స్వరం మద్దతు డాక్యుమెంటేషన్లో మద్దతు ఉన్న భాషల జాబితా మరియు వాటి లోకల్ పేర్లను చూడవచ్చు.

   TOKEN_URL స్థిరాంకం టోకెన్ ఇష్యూ చేసే URL, లొకేషన్ లేకుండా ఉంటుంది. పూర్తి URLని పొందడానికి తర్వాతలో లొకేషన్‌తో కలిపి ఉపయోగిస్తారు.

4. Custom Vision కి కనెక్ట్ అవ్వడంలాంటిదే, టోకెన్ జారీ చేసే సర్వీస్ కు HTTPS కనెక్షన్ అవసరం. config.h చివరకి ఈ క్రింది కోడ్ జోడించండి:

   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 కి కనెక్ట్ అయ్యేటప్పుడు ఉపయోగించిన అదే సర్టిఫికేట్.

5. main.cpp ఫైల్ టాప్‌లో WiFi హెడర్ ఫైల్ మరియు config.h హెడర్ ఫైల్ కోసం include జోడించండి:

   #include <rpcWiFi.h>
   
   #include "config.h"
   

6. main.cppలో setup ఫంక్షన్ తర్వాత WiFi కి కనెక్ట్ కావడానికి ఈ క్రింద చూపిన కోడ్ జోడించండి:

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

7. సీరియల్ కనెక్షన్ స్థాపించిన తర్వాత setup ఫంక్షన్ నుండి ఈ ఫంక్షన్ పిలవండి:

   connectWiFi();
   

8. src ఫోల్డర్‌లో speech_to_text.h అనే కొత్త హెడర్ ఫైల్ సృష్టించి, అందులో ఈ క్రింది కోడ్ జోడించండి:

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

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

   WiFiClientSecure _token_client;
   String _access_token;
   

   _token_client అనేది HTTPS ఉపయోగించే WiFi క్లయింట్, ఇది యాక్సెస్ టోకెన్ పొందడానికి వాడబడుతుంది. టోకెన్ తర్వాత _access_tokenలో నిల్వ ఉంటుంది.

10. private సెక్షన్‌కి క్రింది మెథడ్‌ను జోడించండి:

    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 రిక్వెస్ట్ చేస్తున్నప్పుడు పొరపాట్లు వస్తే మళ్లీ ప్రయత్నిస్తుంది. చివరగా యాక్సెస్ టోకెన్‌ను రిటర్న్ చేస్తుంది.

11. public సెక్షన్‌లో, యాక్సెస్ టోకెన్ పొందడానికి ఒక మెథడ్ జోడించండి. టెక్స్ట్ నుండి స్పీచ్ మార్పిడి తదుపరి పాఠాలలో ఈ టోకెన్ అవసరం అవుతుంది.

    String AccessToken()
    {
        return _access_token;
    }
    

12. public సెక్షన్‌లో, టోకెన్ క్లయెంట్ను సెట్ చేసే init మెథడ్ జోడించండి:

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

    ఇది WiFi క్లయింట్ మీద సర్టిఫికేట్ ఉంచి, తరువాత యాక్సెస్ టోకెన్ పొందుతుంది.

13. main.cppలో ఈ కొత్త హెడర్ ఫైల్ కోసం include డైరెక్టివ్ జోడించండి:

    #include "speech_to_text.h"
    

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

    speechToText.init();
    

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

1. ఈ పాఠం ముందు భాగంలో ఆడియోను ఫ్లాష్ మెమరీకి రికార్డ్ చేశాం. ఆ ఆడియో స్పీచ్ సర్వీస్ REST APIకి పంపాలి, కాబట్టి ఫ్లాష్ మెమరీ నుండి ఆవు చదవాలి. అది బఫర్‌లో లోడ్ చేయలేం ఎందుకంటే చాలా పెద్దది. REST కాల్స్ చేసే HTTPClient క్లాస్ ఆర్డునో స్ట్రీమ్ ఉపయోగించి డేటాను చిన్న చిన్న బ్లాకులుగా పక్కనపక్కన పంపగలదు. ప్రతి సారి మీరు స్ట్రీమ్‌పై read పిలిస్తే తదుపరి డేటా బ్లాక్ వస్తుంది. అర్డునో స్ట్రీమ్‌ను క్రియేట్ చేసి ఫ్లాష్ మెమరీ నుండి చదవగలదు. src ఫోల్డర్‌లో flash_stream.h అనే కొత్త ఫైల్ సృష్టించి, ఇక్కడ ఈ క్రింది కోడ్ జోడించండి:

   #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

2. private సెక్షన్‌లో క్రింది ఫీల్డ్స్ జోడించండి:

   size_t _pos;
   size_t _flash_address;
   const sfud_flash *_flash;
   
   byte _buffer[HTTP_TCP_BUFFER_SIZE];
   

   ఇది ఫ్లాష్ మెమరీ నుండి చదివిన డేటాను నిల్వ చేయడానికి తాత్కాలిక బఫర్, బఫర్ నుండి చదవడానికి ప్రస్తుత స్థానాన్ని మరియు ఫ్లాష్ మెమరీ నుంచి చదవాల్సిన ప్రస్తుత అడ్రెస్, ఫ్లాష్ మెమరీ డివైస్ గల ఫీల్డ్స్‌ను నిర్వచిస్తుంది.

3. private సెక్షన్‌లో ఈ క్రింది మెథడ్ జోడించండి:

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

   ఈ కోడ్ ప్రస్తుత అడ్రెస్ నుంచి ఫ్లాష్ మెమరీ చదవడమే కాదు, ఆ డేటాను బఫర్‌లో ఉంచుతుంది. తర్వాత అడ్రస్ పెంచుతుంది కాబట్టి తదుపరి పిలుపు తర్వాతి మెమరీ బ్లాక్ చదవగలదు. బఫర్ సైజ్ REST APIకి HTTPClient ఒకేసారి పంపే అతిపెద్ద చంక్ ఆధారంగా ఉంటుంది.

   💁 ఫ్లాష్ మెమరీ తొలగింపును గ్రైన్ సైజ్‌తో చేయాలి కానీ చదవడం ఆ విధంగా ఉండదు.

4. ఈ క్లాస్ యొక్క public సెక్షన్‌లో కన్‌స్ట్రక్టర్ జోడించండి:

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

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

5. write మెథడ్‌ని ఇంప్లిమెంట్ చేయండి. ఈ స్ట్రీమ్ కేవలం చదివిస్తుంది కాబట్టి ఇది ఎలాంటి పనీ చేయకుండా 0 రిటర్న్ చేస్తుంది:

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

6. peek మెథడ్ ఇంప్లిమెంట్ చేయండి. ఇది ప్రస్తుత స్థానంలోని డేటాను స్ట్రీమ్‌ను ముందుకు తిప్పకుండా రిటర్న్ చేస్తుంది. ఒకదాన్ని పిలవడమైతే, ఆ డేటానే ఎప్పుడూ తిరిగి ఇస్తుంది.

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

7. available ఫంక్షన్ ఇంప్లిమెంట్ చేయండి. ఇది స్ట్రీమ్ నుండి చదవగల బైట్ల తదిని (లేదా స్ట్రీమ్ పూర్తయితే -1) రిటర్న్ చేస్తుంది. ఈ క్లాస్‌కు ఎక్కువగా అందుబాటులో ఉన్న డేటా HTTPClient యొక్క చంక్ సైజ్ కన్నా ఎక్కువ ఉండదు. HTTPClient ఈ పద్ధతిని పిలిచినప్పుడు ఎన్ని బైట్లు అందుబాటులో ఉన్నాయో తెలుసుకుని ఆ మేరకు REST APIకి డేటా పంపుతుంది. మరికొన్ని ఉన్నా చాలా పెద్దవిగా కాకుండా చంక్ సైజ మాత్రమే రిటర్న్ చేస్తుంది. అందుబాటులో తక్కువ ఉంటే అది రిటర్న్ చేస్తుంది. మొత్తం డేటా స్ట్రీమ్ అయ్యాక -1 రిటర్న్ అవుతుంది.

   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;
   }
   

8. read మెథడ్ ఇంప్లిమెంట్ చేసి బఫర్ నుండి తదుపరి బైట్ ఇవ్వండి మరియు స్థానాన్ని పెంచండి. స్థానము బఫర్ పరిమాణం దాటినప్పటికే తదుపరి ఫ్లాష్ మెమరీ బ్లాక్ డేటాతో బఫర్‌ను నింపి స్థానాన్ని రీసెట్ చేస్తుంది.

   virtual int read()
   {
       int retVal = _buffer[_pos++];
   
       if (_pos == HTTP_TCP_BUFFER_SIZE)
       {
           populateBuffer();
       }
   
       return retVal;
   }
   

9. speech_to_text.h హెడర్ ఫైల్‌లో ఈ కొత్త హెడర్ ఫైల్ కోసం include డైరెక్టివ్ జోడించండి:

   #include "flash_stream.h"
   

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

1. స్పీచ్ స్పీచ్ సర్వీస్ REST APIకి ఆడియో పంపడం ద్వారా టెక్స్ట్‌గా మార్చవచ్చు. ఈ REST APIకి టోకెన్ ఇష్యూర్ చేసే సర్టిఫికేట్‌తో భిన్నమైన సర్టిఫికేట్ ఉంటుంది, అందుకని ఈ క్రింది కోడ్ config.h లో జోడించండి:

   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";
   

2. లొకేషన్ లేకుండా స్పీచ్ URL కోసం ఒక స్థిరాంకం ఈ ఫైలులో జోడించండి. తర్వాతలో లొకేషన్, భాషతో కలిపి పూర్తి URL పొందడానికి ఇది ఉపయోగపడుతుంది.

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

3. speech_to_text.h లో SpeechToText క్లాస్ యొక్క private సెక్షన్‌లో స్పీచ్ సర్టిఫికేట్ ఉపయోగించే WiFi క్లయింట్ కోసం ఫీల్డ్ డిఫైన్ చేయండి:

   WiFiClientSecure _speech_client;
   

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

   _speech_client.setCACert(SPEECH_CERTIFICATE);
   

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

   String convertSpeechToText()
   {
   
   }
   

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

   char url[128];
   sprintf(url, SPEECH_URL, SPEECH_LOCATION, LANGUAGE);
   
   HTTPClient httpClient;
   httpClient.begin(_speech_client, url);
   

7. కనెక్షన్ హెడర్లు ఈ క్రింద చూపిన విధంగా సెట్ చేయాలి:

   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 ఫార్మాట్‌లో ఫలితాన్ని కోరడం చెప్పారు.

8. తరువాత, REST API కాల్‌ కోసం క్రింది కోడ్ జోడించండి:

   Serial.println("Sending speech...");
   
   FlashStream stream;
   int httpResponseCode = httpClient.sendRequest("POST", &stream, BUFFER_SIZE);
   
   Serial.println("Speech sent!");
   

   ఇది ఒక FlashStream క్రియేట్ చేసి దానితో REST APIకి డేటాను స్ట్రీమ్ చేస్తుంది.

9. కింద ఈ కోడ్ జోడించండి:

   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 ఖాళీగా ఉంచుతుంది.

10. ఈ మెథడ్ చివర HTTP క్లయింట్ క్లోజ్ చేసి textని రిటర్న్ చేయడానికి క్రింది కోడ్ జోడించండి:

    httpClient.end();
    
    return text;
    

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

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

12. ఈ కోడ్ కంపైల్ చేసి, Wio Terminalకి అప్లోడ్ చేసి సీరియల్ మానిటర్ ద్వారా తనిఖీ చేయండి. ఒకసారి సీరియల్ మానిటర్‌లో Ready కనిపించిన తర్వాత, ఎడమవైపు C బటన్ (పవర్ స్విచ్ దగ్గర, ఎడమవైపు) నొక్కి మాట్లాడండి. 4 సెకన్ల ఆడియో క్యాప్చర్ అయి, టెక్స్ట్‌గా మారుతుంది.

    --- 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 ఫోల్డర్‌లో చూడవచ్చు.

😀 మీ స్పీచ్ టు టెక్స్ట్ ప్రోగ్రామ్ విజయవంతమైంది!

---

అస్వీకరణ:
ఈ డాక్యుమెంట్ AI అనువాద సేవ Co-op Translator ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వాన్ని సాధించడానికి ప్రయత్నిస్తున్నప్పటికీ, ఆటోమేటెడ్ అనువాదాలు లోపాలు లేదా తప్పిదాలు ఉండవచ్చు. స్థానిక భాషలో ఉన్న మూల డాక్యుమెంట్‌ను అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారం కోసం, ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం సూచించబడుతుంది. ఈ అనువాదం వలన ఉద్భవించే ఏవైనా అర్థం తప్పుదోవ పడటం లేదా తప్పు అన్వయాలకు మేము బాధ్యత వహించము.