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.
527 lines
39 KiB
527 lines
39 KiB
# మాటల్ని మాట్లాడటానికి - Wio టెర్మినల్
|
|
|
|
ఈ పాఠం భాగంలో, మీరు మాటల్ని మాట్లాడటానికి మార్చి మాట్లాడే ఫీడ్బ్యాక్ ఇవ్వబోతున్నారు.
|
|
|
|
## మాటల్ని మాట్లాడటం
|
|
|
|
గత పాఠంలో మాటలను టెక్స్ట్కు మార్చడానికి మీరు ఉపయోగించిన స్పీచ్ సర్వీసెస్ SDKని మాటలను తిరిగి మాటలుగా మార్చడానికి కూడా ఉపయోగించవచ్చు.
|
|
|
|
## వాయిసుల జాబితా పొందండి
|
|
|
|
మాట కోరేటప్పుడు, మీరు ఉపయోగించాల్సిన వాయిస్ అందించాలి, ఎందుకంటే మాటలు వివిధ వాయిసుల ద్వారా ఉత్పత్తి చేయబడవచ్చు. ప్రతి భాష వివిధ వాయిసుల శ్రేణిని మద్దతు ఇస్తుంది, మరియు మాట్లాడటం సర్వీసెస్ SDK నుండి ప్రతి భాషకు మద్దతు ఇస్తున్న వాయిసుల జాబితా పొందవచ్చు. మైక్రోకంట్రోలర్ల పరిమితులు ఇక్కడ ప్రాముఖ్యత పొందుతాయి - మాటలకు టెక్స్ట్ సేవల ద్వారా మద్దతు ఇచ్చే వాయిసుల జాబితాను పొందడానికి పిలుపు 77KBకు పైగా ఉన్న JSON డాక్యుమెంట్, ఇది Wio టెర్మినల్ ద్వారా ప్రాసెస్ చేయడానికి చాలా పెద్దది. రాస్తున్న సమయానికి, పూర్తి జాబితా 215 వాయిసులను కలిగి ఉంది, ప్రతి వాయిస్ క్రింది JSON డాక్యుమెంట్ రూపంలో నిర్వచించబడింది:
|
|
|
|
```json
|
|
{
|
|
"Name": "Microsoft Server Speech Text to Speech Voice (en-US, AriaNeural)",
|
|
"DisplayName": "Aria",
|
|
"LocalName": "Aria",
|
|
"ShortName": "en-US-AriaNeural",
|
|
"Gender": "Female",
|
|
"Locale": "en-US",
|
|
"StyleList": [
|
|
"chat",
|
|
"customerservice",
|
|
"narration-professional",
|
|
"newscast-casual",
|
|
"newscast-formal",
|
|
"cheerful",
|
|
"empathetic"
|
|
],
|
|
"SampleRateHertz": "24000",
|
|
"VoiceType": "Neural",
|
|
"Status": "GA"
|
|
}
|
|
```
|
|
|
|
ఈ JSON **Aria** వాయిస్ కోసం ఉంది, దీనికి బహుళ వాయిస్ శైలులు ఉన్నాయి. మాటలకు టెక్స్ట్ నుండి మార్చేటప్పుడు కావలసిందే గల చిన్న పేరు, `en-US-AriaNeural`.
|
|
|
|
ఈ మొత్తం జాబితాను మీ మైక్రోకంట్రోల్లర్లో డౌનલోడ్ చేసి డీకోడ్ చేయడం బదులు, మీరు ఉపయోగిస్తున్న భాష కోసం వాయిసుల జాబితాను పొందడానికి మరింత సర్వర్ లెస్ కోడ్ రాయాలి, మరుచకుండా దీనిని మీ Wio టెర్మినల్ నుండి పిలవాలి. మీ కోడ్ ఆ జాబితా నుండి అనుకూల వాయిస్ని ఎంచుకోవచ్చు, మొదటి ఒక్కటి మిగిల్చి.
|
|
|
|
### పని - వాయిసుల జాబితా పొందడానికి సర్వర్ లెస్ ఫంక్షన్ సృష్టించండి
|
|
|
|
1. మీ `smart-timer-trigger` ప్రాజెక్ట్ను VS Codeలో తెరవండి, మరియు టెర్మినల్లో వర్చువల్ ఎన్విరాన్మెంట్ సక్రియంగా ఉందో చూసుకోండి. లేకపోతే, టెర్మినల్ను మూసివేసి తిరిగి సృష్టించండి.
|
|
|
|
1. `local.settings.json` ఫైల్ తెరువు మరియు స్పీచ్ API కీ మరియు ప్రాంతం కొరకు సెట్టింగ్స్ జోడించండి:
|
|
|
|
```json
|
|
"SPEECH_KEY": "<key>",
|
|
"SPEECH_LOCATION": "<location>"
|
|
```
|
|
|
|
`<key>` ని మీ స్పీచ్ సర్వీస్ వనరు API కీతో మార్చండి. `<location>` ను మీరు స్పీచ్ సర్వీస్ వనరు సృష్టించిన ప్రాంతంతో భర్తీ చేయండి.
|
|
|
|
1. ఈ యాప్కు ఒక కొత్త HTTP ట్రిగ్గర్ `get-voices` అనే పేరుతో క్రింది కమాండ్ ఉపయోగించి జోడించండి, అది functions యాప్ ప్రాజెక్ట్ మౌలిక ఫోల్డర్లో ఉన్న VS Code టెర్మినల్ నుండి జరగాలి:
|
|
|
|
```sh
|
|
func new --name get-voices --template "HTTP trigger"
|
|
```
|
|
|
|
ఇది `get-voices` HTTP ట్రిగ్గర్ను సృష్టిస్తుంది.
|
|
|
|
1. `get-voices` ఫోల్డర్లోని `__init__.py` ఫైల్ యొక్క కంటెంట్ క్రింద ఇవ్వబడిన కోడ్తో మార్చండి:
|
|
|
|
```python
|
|
import json
|
|
import os
|
|
import requests
|
|
|
|
import azure.functions as func
|
|
|
|
def main(req: func.HttpRequest) -> func.HttpResponse:
|
|
location = os.environ['SPEECH_LOCATION']
|
|
speech_key = os.environ['SPEECH_KEY']
|
|
|
|
req_body = req.get_json()
|
|
language = req_body['language']
|
|
|
|
url = f'https://{location}.tts.speech.microsoft.com/cognitiveservices/voices/list'
|
|
|
|
headers = {
|
|
'Ocp-Apim-Subscription-Key': speech_key
|
|
}
|
|
|
|
response = requests.get(url, headers=headers)
|
|
voices_json = json.loads(response.text)
|
|
|
|
voices = filter(lambda x: x['Locale'].lower() == language.lower(), voices_json)
|
|
voices = map(lambda x: x['ShortName'], voices)
|
|
|
|
return func.HttpResponse(json.dumps(list(voices)), status_code=200)
|
|
```
|
|
|
|
ఈ కోడ్ వాయిసులను పొందడానికి ఎండ్పాయింట్కు HTTP అభ్యర్థన చేస్తుంది. ఈ వాయిసుల జాబితా అన్ని భాషలకు వాయిసులతో కూడిన పెద్ద JSON బ్లాక్, కాబట్టి అభ్యర్థన బాడీలో పాస్ చేసిన భాషకు సంబంధించిన వాయిసులు ఫిల్టర్ అవుతాయి, తర్వాత వాటి చిన్న పేర్లు తీసుకుని JSON జాబితాగా తిరిగి ఇవ్వబడతాయి. చిన్న పేరు టెక్స్ట్ నుండి మాటలోకి మార్చడానికి అవసరమైన విలువ, అందువల్ల మాత్రమే ఇది తిరిగి ఇస్తారు.
|
|
|
|
> 💁 మీరు కావాలనుకునే వాయిసులను ఎంచుకునేలా ఫిల్టర్ను మార్చుకోవచ్చు.
|
|
|
|
ఇది వాయిసుల పరిమాణం 77KB (రాస్తున్న సమయానికి) నుండి చాలా చిన్న JSON డాక్యుమెంట్ గా తగ్గిస్తుంది. ఉదాహరణకు, US వాయిసుల కోసం ఇది 408 బైట్ల పరిమాణం మాత్రమే.
|
|
|
|
1. మీరు ఫంక్షన్ యాప్ను లోకల్గా నడపండి. తర్వాత మీరు curl వంటివి ఉపయోగించి `text-to-timer` HTTP ట్రిగ్గర్ను పరీక్షించిన విధంగా దీన్ని పిలవవచ్చు. తప్పకుండా మీ భాషను JSON బాడీగా పంపండి:
|
|
|
|
```json
|
|
{
|
|
"language":"<language>"
|
|
}
|
|
```
|
|
|
|
`<language>` ను మీ భాషతో భర్తీ చేయండి, ఉదాహరణకు `en-GB`, లేదా `zh-CN`.
|
|
|
|
> 💁 ఈ కోడ్ మీరు [code-spoken-response/functions](../../../../../6-consumer/lessons/3-spoken-feedback/code-spoken-response/functions) ఫోల్డర్లో కనుగొనవచ్చు.
|
|
|
|
### పని - మీ Wio టెర్మినల్ నుండి వాయిస్ పొందండి
|
|
|
|
1. `smart-timer` ప్రాజెక్టును VS Codeలో తెరవండి, ఇది ముందే తెరిచివుండకపోతే.
|
|
|
|
1. `config.h` హెడ్డర్ ఫైల్ తెరవండి మరియు మీ ఫంక్షన్ యాప్ URL జోడించండి:
|
|
|
|
```cpp
|
|
const char *GET_VOICES_FUNCTION_URL = "<URL>";
|
|
```
|
|
|
|
`<URL>` ని మీరు ఫంక్షన్ యాప్లోని `get-voices` HTTP ట్రిగ్గర్ URL తో మార్చండి. ఇది `TEXT_TO_TIMER_FUNCTION_URL` విలువ వంటి ఉంటుంది, కాని ఫంక్షన్ పేరు `text-to-timer` కాకుండా `get-voices` అవుతుంది.
|
|
|
|
1. `src` ఫోల్డర్లో `text_to_speech.h` అనే కొత్త ఫైల్ సృష్టించండి. దీన్ని టెక్స్ట్ నుండి మాట్లాడటానికి మార్పిడి చేసే క్లాస్ డిఫైన్ చేయడానికి ఉపయోగిస్తారు.
|
|
|
|
1. కొత్త `text_to_speech.h` ఫైల్పు టాప్లో క్రింది ఇన్క్లూడ్ డైరెక్టివ్లను జోడించండి:
|
|
|
|
```cpp
|
|
#pragma once
|
|
|
|
#include <Arduino.h>
|
|
#include <ArduinoJson.h>
|
|
#include <HTTPClient.h>
|
|
#include <Seeed_FS.h>
|
|
#include <SD/Seeed_SD.h>
|
|
#include <WiFiClient.h>
|
|
#include <WiFiClientSecure.h>
|
|
|
|
#include "config.h"
|
|
#include "speech_to_text.h"
|
|
```
|
|
|
|
1. ఈ క్రింద ఇవ్వబడిన కోడ్ను జత చేసి `TextToSpeech` క్లాస్ డిక్లేర్ చేయండి, తదుపరి అప్లికేషన్లో ఉపయోగించుకునే ఒక ఇన్స్టాన్స్ కూడా:
|
|
|
|
```cpp
|
|
class TextToSpeech
|
|
{
|
|
public:
|
|
private:
|
|
};
|
|
|
|
TextToSpeech textToSpeech;
|
|
```
|
|
|
|
1. ఫంక్షన్ యాప్ పిలవడానికి, WiFi క్లయింట్ను డిక్లేర్ చేయాలి. క్లాస్ `private` విభాగంలో ఈ క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
WiFiClient _client;
|
|
```
|
|
|
|
1. `private` విభాగంలో, ఎంచుకున్న వాయిస్ కొరకు ఒక ఫీల్డ్ జోడించండి:
|
|
|
|
```cpp
|
|
String _voice;
|
|
```
|
|
|
|
1. `public` విభాగంలో, మొదటి వాయిస్ పొందండికి `init` ఫంక్షన్ జోడించండి:
|
|
|
|
```cpp
|
|
void init()
|
|
{
|
|
}
|
|
```
|
|
|
|
1. వాయిసులు పొందడానికి, ఫంక్షన్ యాప్కు భాషతో JSON డాక్యుమెంట్ పంపాలి. `init` ఫంక్షన్లో ఈ JSON డాక్యుమెంట్ సృష్టించడానికి కింద ఇచ్చిన కోడ్ జతచేయండి:
|
|
|
|
```cpp
|
|
DynamicJsonDocument doc(1024);
|
|
doc["language"] = LANGUAGE;
|
|
|
|
String body;
|
|
serializeJson(doc, body);
|
|
```
|
|
|
|
1. తరువాత ఒక `HTTPClient` సృష్టించి, JSON డాక్యుమెంటును పోస్ట్ చేస్తూ వాయిసులను పొందడానికి ఫంక్షన్ యాప్ను పిలవండి:
|
|
|
|
```cpp
|
|
HTTPClient httpClient;
|
|
httpClient.begin(_client, GET_VOICES_FUNCTION_URL);
|
|
|
|
int httpResponseCode = httpClient.POST(body);
|
|
```
|
|
|
|
1. ఈ క్రింది కోడ్ జత చేసి రీస్పాన్స్ కోడ్ తనిఖీ చేయండి, 200 (విజయం) అయితే వాయిసుల జాబితా తీసుకుని, మొదటి వాయిస్ను పొందండి:
|
|
|
|
```cpp
|
|
if (httpResponseCode == 200)
|
|
{
|
|
String result = httpClient.getString();
|
|
Serial.println(result);
|
|
|
|
DynamicJsonDocument doc(1024);
|
|
deserializeJson(doc, result.c_str());
|
|
|
|
JsonArray obj = doc.as<JsonArray>();
|
|
_voice = obj[0].as<String>();
|
|
|
|
Serial.print("Using voice ");
|
|
Serial.println(_voice);
|
|
}
|
|
else
|
|
{
|
|
Serial.print("Failed to get voices - error ");
|
|
Serial.println(httpResponseCode);
|
|
}
|
|
```
|
|
|
|
1. తరువాత, HTTP క్లయింట్ కనెక్షన్ ముగించండి:
|
|
|
|
```cpp
|
|
httpClient.end();
|
|
```
|
|
|
|
1. `main.cpp` ఫైల్ తెరిచి, క్రింది ఇన్క్లూడ్ డైరెక్టివ్ జతచేయండి:
|
|
|
|
```cpp
|
|
#include "text_to_speech.h"
|
|
```
|
|
|
|
1. `setup` ఫంక్షన్లో, `speechToText.init();` పిలుపు పైన ఈ క్రింది కోడ్ జోడించి `TextToSpeech` క్లాస్ ఇనిషియలైజ్ చేయండి:
|
|
|
|
```cpp
|
|
textToSpeech.init();
|
|
```
|
|
|
|
1. ఈ కోడ్ బిల్డ్ చేసి, Wio టెర్మినల్కు అప్లోడ్ చేసి, సీరియల్ మానిటర్ ద్వారా పరీక్షించండి. మీ ఫంక్షన్ యాప్ నడుస్తున్నందుకు ఖచ్చితంగా చూసుకోండి.
|
|
|
|
ఫంక్షన్ యాప్ నుండి అందుబాటులో ఉన్న వాయిసుల జాబితా మరియు ఎంచుకున్న వాయిస్ ఎలాంటి కనిపిస్తాయి.
|
|
|
|
```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.
|
|
["en-US-JennyNeural", "en-US-JennyMultilingualNeural", "en-US-GuyNeural", "en-US-AriaNeural", "en-US-AmberNeural", "en-US-AnaNeural", "en-US-AshleyNeural", "en-US-BrandonNeural", "en-US-ChristopherNeural", "en-US-CoraNeural", "en-US-ElizabethNeural", "en-US-EricNeural", "en-US-JacobNeural", "en-US-MichelleNeural", "en-US-MonicaNeural", "en-US-AriaRUS", "en-US-BenjaminRUS", "en-US-GuyRUS", "en-US-ZiraRUS"]
|
|
Using voice en-US-JennyNeural
|
|
Ready.
|
|
```
|
|
|
|
## టెక్స్ట్ నుండి మాటలుగా మార్చడం
|
|
|
|
మీకు ఉపయోగించడానికి వాయిస్ అందిన తర్వాత, దాన్ని టెక్స్ట్ నుండి మాటలుగా మార్చడానికి ఉపయోగించవచ్చు. మాటల నుండి టెక్స్ట్ మార్చేటప్పుడు వాయిసుల తో పాటు ఉన్న మేమరీ పరిమితులు ఇక్కడ కూడా వర్తిస్తాయి, కాబట్టి మీరు స్వరం ReSpeaker ద్వారా ప్లే చేయడానికి ముందుగా SD కార్డులో స్టోర్ చేయవలసి ఉంటుంది.
|
|
|
|
> 💁 ఈ ప్రాజెక్ట్లో ముందటి పాఠాలలో మైక్రోఫోన్లో నించి మాటలను నిల్వ చేయడానికి ఫ్లాష్ మెమరీ ఉపయోగించారు. ఈ పాఠం Seeed ఆడియో లైబ్రరీలతో ఆడియో ప్లే చేయటానికి SD కార్డును ఉపయోగిస్తుంది, ఇది సులభమైన మార్గం.
|
|
|
|
ఇంకో పరిమితి ఆڊيو డేటా మరియు Wio టెర్మినల్ మద్దతు ఇచ్చే ఫార్మాట్ల పరిమితి. పూర్తి కంప్యూటర్లు వద్ద (PC లు) లాంటి అనేక ఆడియో ఫార్మ্যাট్లు ఉంటే, మైక్రోకంట్రోలర్ల ఆడియో లైబ్రరీలు చాలా పరిమితమైన ఆడియో ఫార్మాట్లనే మద్దతు ఇస్తాయి. ఉదాహరణకి, Seeed ఆర్డినో ఆడియో లైబ్రరీ ReSpeaker మీద సౌండ్ ప్లే చేయడానికి 44.1KHz శాంపిల్ రేటు మాత్రమే మద్దతు ఇస్తుంది. Azure మాటల సేవలు అనేక ఫార్మాట్లలో ఆడియో అందిస్తాయి, కానీ అవి 44.1KHz కాదూ, అవి 8KHz, 16KHz, 24KHz మరియు 48KHzే అందిస్తాయి. అంటే ఆడియోను 44.1KHzకి రీసాంపుల్ చేయాల్సి ఉంటుంది, ఇది Wio టెర్మినల్ దగ్గర ఎక్కువ రిసోర్సులు, ముఖ్యంగా మెమరీ అవసరం.
|
|
|
|
ఈ రకమైన డేటాను మార్చేటప్పుడు, సాధారణంగా సర్వర్ లెస్ కోడ్ ఉపయోగించడం మంచిది, ముఖ్యంగా డేటాను వెబ్ పిలుపు ద్వారా పొందుతున్నప్పుడు. Wio టెర్మినల్ టెక్స్ట్ను సర్వర్ లెస్ ఫంక్షన్కు పంపవచ్చు, ఆ సర్వర్ లెస్ ఫంక్షన్ మాటల సేవను పిలిచి, టెక్స్ట్ నుండి మాటలోకి మార్చడంతో పాటుగా ఆడియోను అవసరమైన శాంపిల్ రేటుకు రీసాంపుల్ చేయవచ్చు. ఆపై ఇది ఆడియోను Wio టెర్మినల్ SD కార్డులో స్టోర్ చేసుకునే ఫార్మాట్ లో తిరిగి పంపుతుంది, తద్వారా ReSpeaker ద్వారా ప్లే చేయవచ్చు.
|
|
|
|
### పని - టెక్స్ట్ నుండి మాటలుగా మార్చే సర్వర్ లెస్ ఫంక్షన్ సృష్టించండి
|
|
|
|
1. మీ `smart-timer-trigger` ప్రాజెక్టును VS Codeలో తెరవండి, టెర్మినల్లో వర్చువల్ ఎన్విరాన్మెంట్ సక్రియంగా ఉందనేదాన్ని ధృవీకరించండి. లేకపోతే టెర్మినల్ను ముగించి మళ్ళీ సృష్టించండి.
|
|
|
|
1. ఈ ప్రాజెక్టుకు `text-to-speech` అనే కొత్త HTTP ట్రిగ్గర్ జోడించడానికి క్రింది కమాండ్ ఉపయోగించండి, ఇది functions యాప్ అంతర్గత రూట్ ఫోల్డర్ VS Code టెర్మినల్లో అమలు చేయాలి:
|
|
|
|
```sh
|
|
func new --name text-to-speech --template "HTTP trigger"
|
|
```
|
|
|
|
ఇది `text-to-speech` పేరుతో HTTP ట్రిగ్గర్ను సృష్టిస్తుంది.
|
|
|
|
1. [librosa](https://librosa.org) పిప్ ప్యాకేజ్ ఆడియోను రీసాంపుల్ చేసే ఫంక్షన్స్ కలిగిఉంది, కాబట్టి దీన్ని `requirements.txt` లో జోడించండి:
|
|
|
|
```sh
|
|
librosa
|
|
```
|
|
|
|
ఇది జత చేసిన తరువాత, ఫాలోవింగ్ కమాండ్ ఉపయోగించి పిప్ ప్యాకేజులు ఇన్స్టాల్ చేయండి:
|
|
|
|
```sh
|
|
pip install -r requirements.txt
|
|
```
|
|
|
|
> ⚠️ మీరు లినక్స్ ఉపయోగిస్తుంటే, రాస్ప్బెర్రీ పై OS సహా `libsndfile` ఇన్స్టాల్ చేయాల్సి ఉండొచ్చు, ఈ కింద ఉంటూనే కమాండ్తో:
|
|
>
|
|
> ```sh
|
|
> sudo apt update
|
|
> sudo apt install libsndfile1-dev
|
|
> ```
|
|
|
|
1. టెక్స్ట్ ను మాటలుగా మార్చడానికి, మీరు స్పీచ్ API కీను నేరుగా ఉపయోగించలేరు, అందుకు బదులు API కీతో సరైన ప్రామాణీకరణతో యాక్సెస్ టోకెన్ ని కోరాలి. `text-to-speech` ఫోల్డర్లోని `__init__.py` ఫైల్ పూర్ణంగా క్రింది కోడ్తో మార్చండి:
|
|
|
|
```python
|
|
import io
|
|
import os
|
|
import requests
|
|
|
|
import librosa
|
|
import soundfile as sf
|
|
import azure.functions as func
|
|
|
|
location = os.environ['SPEECH_LOCATION']
|
|
speech_key = os.environ['SPEECH_KEY']
|
|
|
|
def get_access_token():
|
|
headers = {
|
|
'Ocp-Apim-Subscription-Key': speech_key
|
|
}
|
|
|
|
token_endpoint = f'https://{location}.api.cognitive.microsoft.com/sts/v1.0/issuetoken'
|
|
response = requests.post(token_endpoint, headers=headers)
|
|
return str(response.text)
|
|
```
|
|
|
|
ఇది సెట్టింగ్స్ నుండి పఠించబడే ప్రాంతం మరియు స్పీచ్ కీకి కాన్స్టెంట్స్ నిర్వచిస్తుంది. అలాగే స్పీచ్ సేవ కోసం యాక్సెస్ టోకెన్ పొందే `get_access_token` ఫంక్షన్ నిర్వచిస్తుంది.
|
|
|
|
1. ఈ కోడ్ క్రింద, క్రింది కోడ్ జతచేయండి:
|
|
|
|
```python
|
|
playback_format = 'riff-48khz-16bit-mono-pcm'
|
|
|
|
def main(req: func.HttpRequest) -> func.HttpResponse:
|
|
req_body = req.get_json()
|
|
language = req_body['language']
|
|
voice = req_body['voice']
|
|
text = req_body['text']
|
|
|
|
url = f'https://{location}.tts.speech.microsoft.com/cognitiveservices/v1'
|
|
|
|
headers = {
|
|
'Authorization': 'Bearer ' + get_access_token(),
|
|
'Content-Type': 'application/ssml+xml',
|
|
'X-Microsoft-OutputFormat': playback_format
|
|
}
|
|
|
|
ssml = f'<speak version=\'1.0\' xml:lang=\'{language}\'>'
|
|
ssml += f'<voice xml:lang=\'{language}\' name=\'{voice}\'>'
|
|
ssml += text
|
|
ssml += '</voice>'
|
|
ssml += '</speak>'
|
|
|
|
response = requests.post(url, headers=headers, data=ssml.encode('utf-8'))
|
|
|
|
raw_audio, sample_rate = librosa.load(io.BytesIO(response.content), sr=48000)
|
|
resampled = librosa.resample(raw_audio, sample_rate, 44100)
|
|
|
|
output_buffer = io.BytesIO()
|
|
sf.write(output_buffer, resampled, 44100, 'PCM_16', format='wav')
|
|
output_buffer.seek(0)
|
|
|
|
return func.HttpResponse(output_buffer.read(), status_code=200)
|
|
```
|
|
|
|
ఇది టెక్స్ట్ను మాటలోకి మార్చే HTTP ట్రిగ్గర్ను నిర్వచిస్తుంది. JSON బాడీలో టెక్స్ట్, భాష, వాయిస్ తీసి, SSML ని రూపొందించి, యాక్సెస్ టోకెన్తో ప్రామాణీకరించిన సంబంధిత రెస్ట్ APIకి పిలుస్తుంది. ఈ రెస్ట్ API కాల్ 16-బిట్, 48KHz మోనో WAV ఫైల్ ఆడియోను తిరిగి ఇస్తుంది, `playback_format` విలువ అనుసారం. ఆ తర్వాత ఇది `librosa` ద్వారా 48KHz నుండి 44.1KHzకి రీసాంపుల్ అవుతుంది, ఆ ఆడియో బైనరీ బఫర్ గా సేవ్ చేసి తిరిగి ఇస్తుంది.
|
|
|
|
1. ఫంక్షన్ యాప్ను స్థానికంగా నడిపించండి, లేదా క్లౌడ్కు అభ్యర్థించండి. మీరు `text-to-timer` HTTP ట్రిగ్గర్ను పరీక్షించినదాన్ని అనుసరించి, curl వంటి టూల్ ఉపయోగించి దీన్ని పిలవవచ్చు. తప్పకుండా భాష, వాయిస్ మరియు టెక్స్ట్ JSON బాడీగా పంపండి:
|
|
|
|
```json
|
|
{
|
|
"language": "<language>",
|
|
"voice": "<voice>",
|
|
"text": "<text>"
|
|
}
|
|
```
|
|
|
|
`<language>` ను మీ భాషతో, ఉదాహరణకు `en-GB`, లేదా `zh-CN` తో భర్తీ చేయండి. `<voice>` ను మీరు ఉపయోగించాలనుకున్న వాయిస్తో మార్చండి. `<text>` లో మీరు మాటలుగా మార్చదలచిన టెక్స్ట్ ఉంచండి. ఫలితాన్ని ఫైల్గా సేవ్ చేసి WAV ప్లేయర్తో ప్లే చేయొచ్చు.
|
|
|
|
ఉదాహరణకి US ఇంగ్లీష్ Jenny Neural వాయిస్తో "Hello" ని మాటలుగా మార్చాలంటే, ఫంక్షన్ యాప్ స్థానికంగా నడుస్తుండగా, క్రింది curl కమాండ్ ఉపయోగించవచ్చు:
|
|
|
|
```sh
|
|
curl -X GET 'http://localhost:7071/api/text-to-speech' \
|
|
-H 'Content-Type: application/json' \
|
|
-o hello.wav \
|
|
-d '{
|
|
"language":"en-US",
|
|
"voice": "en-US-JennyNeural",
|
|
"text": "Hello"
|
|
}'
|
|
```
|
|
|
|
ఇది ఆడియోను ప్రస్తుత డైరెక్టరీలో `hello.wav` గా సేవ్ చేస్తుంది.
|
|
|
|
> 💁 ఈ కోడ్ మీరు [code-spoken-response/functions](../../../../../6-consumer/lessons/3-spoken-feedback/code-spoken-response/functions) ఫోల్డర్లో కనుగొనవచ్చు.
|
|
|
|
### పని - మీ Wio టెర్మినల్ నుండి మాట పొందండి
|
|
|
|
1. `smart-timer` ప్రాజెక్ట్ తెరవండి, ఇది ముందే తెరవబడకపోతే.
|
|
|
|
1. `config.h` హెడ్డర్ ఫైల్ తెరవండి మరియు మీ ఫంక్షన్ యాప్ URL జత చేయండి:
|
|
|
|
```cpp
|
|
const char *TEXT_TO_SPEECH_FUNCTION_URL = "<URL>";
|
|
```
|
|
|
|
`<URL>` ని మీ ఫంక్షన్ యాప్ లోని `text-to-speech` HTTP ట్రిగ్గర్ URL తో భర్తీ చేయండి. ఇది `TEXT_TO_TIMER_FUNCTION_URL` విలువకు సమానమే, కాని ఫంక్షన్ పేరు `text-to-timer` కాకుండా `text-to-speech` అవుతుంది.
|
|
|
|
1. `text_to_speech.h` హెడ్డర్ ఫైల్ తెరువు, `TextToSpeech` క్లాస్ యొక్క `public` విభాగంలోని క్రింది విధంగా మెథడ్ జోడించండి:
|
|
|
|
```cpp
|
|
void convertTextToSpeech(String text)
|
|
{
|
|
}
|
|
```
|
|
|
|
1. `convertTextToSpeech` మెథడ్కు క్రింద ఇచ్చిన కోడ్ జత చేసి ఫంక్షన్ యాప్కు పంపే JSON సృష్టించండి:
|
|
|
|
```cpp
|
|
DynamicJsonDocument doc(1024);
|
|
doc["language"] = LANGUAGE;
|
|
doc["voice"] = _voice;
|
|
doc["text"] = text;
|
|
|
|
String body;
|
|
serializeJson(doc, body);
|
|
```
|
|
|
|
ఇది JSON డాక్యుమెంట్లో భాష, వాయిస్, టెక్స్ట్ రాస్తుంది, తర్వాత స్ట్రింగ్గా సీరియలైజ్ చేస్తుంది.
|
|
|
|
1. దీని కింద క్రింద ఇవ్వబడిన కోడ్ జత చేయండి, ఫంక్షన్ యాప్ను పిలవడానికి:
|
|
|
|
```cpp
|
|
HTTPClient httpClient;
|
|
httpClient.begin(_client, TEXT_TO_SPEECH_FUNCTION_URL);
|
|
|
|
int httpResponseCode = httpClient.POST(body);
|
|
```
|
|
|
|
ఇది HTTPClient సృష్టించి, JSON డాక్యుమెంట్తో text-to-speech HTTP ట్రిగ్గర్కు POST రిక్వెస్ట్ చేస్తుంది.
|
|
|
|
1. పిలుపు సఫలమైతే, ఫంక్షన్ కాల్ నుండి వచ్చిన రా బైనరీ డేటాను SD కార్డ్ పై ఫైల్గా స్ట్రీమ్ చేయాలి. కింద ఇవ్వబడిన కోడ్ జత చేయండి:
|
|
|
|
```cpp
|
|
if (httpResponseCode == 200)
|
|
{
|
|
File wav_file = SD.open("SPEECH.WAV", FILE_WRITE);
|
|
httpClient.writeToStream(&wav_file);
|
|
wav_file.close();
|
|
}
|
|
else
|
|
{
|
|
Serial.print("Failed to get speech - error ");
|
|
Serial.println(httpResponseCode);
|
|
}
|
|
```
|
|
|
|
ఈ కోడ్ రిస్పాన్స్ తనిఖీ చేసి, 200 (విజయం) అయితే బైనరీ డేటాను SD కార్డ్ మూలలో `SPEECH.WAV` అనే ఫైల్గా స్ట్రీమ్ చేస్తుంది.
|
|
|
|
1. ఈ మెథడ్ చివర్లో HTTP కనెక్షన్ ముగించండి:
|
|
|
|
```cpp
|
|
httpClient.end();
|
|
```
|
|
|
|
1. ఇప్పుడు మాట్లాడు టెక్స్ట్ ఆడియోగా మార్చవచ్చు. `main.cpp` ఫైల్లో, టెక్స్ట్ని మాట్లాడడానికి మార్చేందుకు `say` ఫంక్షన్ చివరగా ఈ క్రింది పంక్తిని జోడించండి:
|
|
|
|
```cpp
|
|
textToSpeech.convertTextToSpeech(text);
|
|
```
|
|
|
|
### పనితీరు - మీ Wio టెర్మినల్ నుండి ఆడియో ప్లే చేయండి
|
|
|
|
**త్వరలో వస్తోంది**
|
|
|
|
## మీ ఫంక్షన్ల యాప్ను క్లౌడ్లో డిప్లాయ్ చేయడం
|
|
|
|
ఫంక్షన్ల యాప్ను స్థానికంగా నడపడం కారణం ఏమంటే, లినక్స్లో `librosa` పిప్ ప్యాకేజీ ఒక లైబ్రరీపై ఆధారపడింది, ఆ లైబ్రరీ డిఫాల్ట్గా ఇన్స్టాల్ కాలేదు, మరియు ఫంక్షన్ యాప్ నడపడానికి ముందు దాన్ని ఇన్స్టాల్ చేయాలి. ఫంక్షన్ యాప్లు సర్వర్లెస్ - మీరు స్వయంగా నిర్వహించగల సర్వర్లు లేరు, కాబట్టి ముందుగా ఆ లైబ్రరీని ఇన్స్టాల్ చేయడానికి కూడా మార్గం లేదు.
|
|
|
|
దీనిని చేయడానికి మార్గం డోకర్ కంటైనర్ ఉపయోగించి మీ ఫంక్షన్ల యాప్ను డిప్లాయ్ చేయడం. ఈ కంటైనర్ క్లౌడ్ ద్వారా మీ ఫంక్షన్ యాప్ యొక్క కొత్త కాపీ అవసరమైనప్పుడు (ఉదాహరణకు డిమాండ్ అందుబాటులో ఉన్న వనరులు మించి ఉన్నప్పుడు, లేదా ఫంక్షన్ యాప్ కొంతకాలం వినియోగించబడకపోతే మూసివేయబడిన సందర్భాలు) స్పిన్ అప్ చేయబడుతుంది.
|
|
|
|
లినక్స్లో కస్టమ్ కంటైనర్ ఉపయోగించి ఫంక్షన్ల యాప్ను సెట్ అప్ చేసి డిప్లాయ్ చేయడంపై సూచనలు మీరు [Microsoft Docsపై create a function on Linux using a custom container దస్త్రంలో](https://docs.microsoft.com/azure/azure-functions/functions-create-function-linux-custom-image?WT.mc_id=academic-17441-jabenn&tabs=bash%2Cazurecli&pivots=programming-language-python) చూడవచ్చు.
|
|
|
|
ఇది డిప్లాయ్ అయితే, ఈ ఫంక్షన్ యాప్ను యాక్సెస్ చేయడానికి మీ Wio టెర్మినల్ కోడ్ పోర్ట్ చేయవచ్చు:
|
|
|
|
1. `config.h` లో Azure Functions సర్టిఫికెట్ జోడించండి:
|
|
|
|
```cpp
|
|
const char *FUNCTIONS_CERTIFICATE =
|
|
"-----BEGIN CERTIFICATE-----\r\n"
|
|
"MIIFWjCCBEKgAwIBAgIQDxSWXyAgaZlP1ceseIlB4jANBgkqhkiG9w0BAQsFADBa\r\n"
|
|
"MQswCQYDVQQGEwJJRTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJl\r\n"
|
|
"clRydXN0MSIwIAYDVQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTIw\r\n"
|
|
"MDcyMTIzMDAwMFoXDTI0MTAwODA3MDAwMFowTzELMAkGA1UEBhMCVVMxHjAcBgNV\r\n"
|
|
"BAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEgMB4GA1UEAxMXTWljcm9zb2Z0IFJT\r\n"
|
|
"QSBUTFMgQ0EgMDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCqYnfP\r\n"
|
|
"mmOyBoTzkDb0mfMUUavqlQo7Rgb9EUEf/lsGWMk4bgj8T0RIzTqk970eouKVuL5R\r\n"
|
|
"IMW/snBjXXgMQ8ApzWRJCZbar879BV8rKpHoAW4uGJssnNABf2n17j9TiFy6BWy+\r\n"
|
|
"IhVnFILyLNK+W2M3zK9gheiWa2uACKhuvgCca5Vw/OQYErEdG7LBEzFnMzTmJcli\r\n"
|
|
"W1iCdXby/vI/OxbfqkKD4zJtm45DJvC9Dh+hpzqvLMiK5uo/+aXSJY+SqhoIEpz+\r\n"
|
|
"rErHw+uAlKuHFtEjSeeku8eR3+Z5ND9BSqc6JtLqb0bjOHPm5dSRrgt4nnil75bj\r\n"
|
|
"c9j3lWXpBb9PXP9Sp/nPCK+nTQmZwHGjUnqlO9ebAVQD47ZisFonnDAmjrZNVqEX\r\n"
|
|
"F3p7laEHrFMxttYuD81BdOzxAbL9Rb/8MeFGQjE2Qx65qgVfhH+RsYuuD9dUw/3w\r\n"
|
|
"ZAhq05yO6nk07AM9c+AbNtRoEcdZcLCHfMDcbkXKNs5DJncCqXAN6LhXVERCw/us\r\n"
|
|
"G2MmCMLSIx9/kwt8bwhUmitOXc6fpT7SmFvRAtvxg84wUkg4Y/Gx++0j0z6StSeN\r\n"
|
|
"0EJz150jaHG6WV4HUqaWTb98Tm90IgXAU4AW2GBOlzFPiU5IY9jt+eXC2Q6yC/Zp\r\n"
|
|
"TL1LAcnL3Qa/OgLrHN0wiw1KFGD51WRPQ0Sh7QIDAQABo4IBJTCCASEwHQYDVR0O\r\n"
|
|
"BBYEFLV2DDARzseSQk1Mx1wsyKkM6AtkMB8GA1UdIwQYMBaAFOWdWTCCR1jMrPoI\r\n"
|
|
"VDaGezq1BE3wMA4GA1UdDwEB/wQEAwIBhjAdBgNVHSUEFjAUBggrBgEFBQcDAQYI\r\n"
|
|
"KwYBBQUHAwIwEgYDVR0TAQH/BAgwBgEB/wIBADA0BggrBgEFBQcBAQQoMCYwJAYI\r\n"
|
|
"KwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTA6BgNVHR8EMzAxMC+g\r\n"
|
|
"LaArhilodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vT21uaXJvb3QyMDI1LmNybDAq\r\n"
|
|
"BgNVHSAEIzAhMAgGBmeBDAECATAIBgZngQwBAgIwCwYJKwYBBAGCNyoBMA0GCSqG\r\n"
|
|
"SIb3DQEBCwUAA4IBAQCfK76SZ1vae4qt6P+dTQUO7bYNFUHR5hXcA2D59CJWnEj5\r\n"
|
|
"na7aKzyowKvQupW4yMH9fGNxtsh6iJswRqOOfZYC4/giBO/gNsBvwr8uDW7t1nYo\r\n"
|
|
"DYGHPpvnpxCM2mYfQFHq576/TmeYu1RZY29C4w8xYBlkAA8mDJfRhMCmehk7cN5F\r\n"
|
|
"JtyWRj2cZj/hOoI45TYDBChXpOlLZKIYiG1giY16vhCRi6zmPzEwv+tk156N6cGS\r\n"
|
|
"Vm44jTQ/rs1sa0JSYjzUaYngoFdZC4OfxnIkQvUIA4TOFmPzNPEFdjcZsgbeEz4T\r\n"
|
|
"cGHTBPK4R28F44qIMCtHRV55VMX53ev6P3hRddJb\r\n"
|
|
"-----END CERTIFICATE-----\r\n";
|
|
```
|
|
|
|
1. `<WiFiClient.h>` లోని అన్ని ఇన్క్లూడ్స్ ను `<WiFiClientSecure.h>` గా మార్చండి.
|
|
|
|
1. అన్ని `WiFiClient` ఫీల్డ్స్ ను `WiFiClientSecure` గా మార్చండి.
|
|
|
|
1. ప్రతి క్లాసులో `WiFiClientSecure` ఫీల్డ్ ఉన్న చోట, ఒక కన్స్ట్రక్టర్ జోడించి ఆ కన్స్ట్రక్టర్లో సర్టిఫికెట్ సెట్ చేయండి:
|
|
|
|
```cpp
|
|
_client.setCACert(FUNCTIONS_CERTIFICATE);
|
|
```
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**హಣికి:**
|
|
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మనం ఖచ్చితత్వం కోసం ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో తప్పులు లేదా లోపాలు ఉండవచ్చు. మూల పత్రం వారి స్వదేశ భాషలోనే అథారిటేటివ్ మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదాన్ని సిఫార్సు చేస్తాము. ఈ అనువాదం వాడకం ద్వారా ఉత్పన్నమయ్యే ఏదైనా అవగాహన లోపాలు లేదా తప్పుదోవ పడే పరిస్థితులకు మేము బాధ్యత వహించము.
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |