You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
537 lines
33 KiB
537 lines
33 KiB
# 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 --> |