40 KiB

Raw Permalink Blame History

ಪಠ್ಯದಿಂದ ಧ್ವನಿಗೆ - Wio ಟರ್ಮಿನಲ್

ಈ ಪಾಠದ ಭಾಗದಲ್ಲಿ, ನೀವು ಮಾತೃಭಾಷೆಯ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ನೀಡಲು ಪಠ್ಯವನ್ನು ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸುವಿರಿ.

ಪಠ್ಯದಿಂದ ಧ್ವನಿಗೆ

ನೀವು ಹಿಂದಿನ ಪಾಠದಲ್ಲಿ ಉಪಯೋಗಿಸಿದ ಧ್ವನಿಯನ್ನು ಪಠ್ಯಕ್ಕೆ ಪರಿವರ್ತಿಸಲುSpeech Services SDK ಅನ್ನು ಪಠ್ಯವನ್ನು ಮರುಪರಿವರ್ತನೆಗೆ ಉಪಯೋಗಿಸಬಹುದು.

ಧ್ವನಿಗಳ ಪಟ್ಟಿ ಪಡೆಯಿರಿ

ಧ್ವನಿಯನ್ನು ವಿನಂತಿಸುವಾಗ, ನೀವು ಉಪಯೋಗಿಸುವ ಧ್ವನಿಯನ್ನು ಒದಗಿಸಬೇಕಾಗುತ್ತದೆ ಏಕೆಂದರೆ ವಿವಿಧ ಧ್ವನಿಗಳಿಂದ ಧ್ವನಿ ಸೃಷ್ಟಿಸಬಹುದು. ಪ್ರತೀ ಭಾಷೆ ವಿವಿಧ ಧ್ವನಿಗಳ ಸದಸ್ಯರನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ನೀವು ಪ್ರತೀ ಭಾಷೆಗೆ ಬೆಂಬಲಿಸುವ ಧ್ವನಿಗಳ ಪಟ್ಟಿಯನ್ನು Speech Services SDK ನಿಂದ ಪಡೆಯಬಹುದು. ಮೈಕ್ರೋಕಾರ್ಟ್ರೋರಗಳ ಮಿತಿ ಇಲ್ಲಿ ಅನ್ವಯವಾಗುತ್ತದೆ - ಪಠ್ಯದಿಂದ ಧ್ವನಿಗೆ ಸೇವೆಗಳ ಬೆಂಬಲಿಸುವ ಧ್ವನಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯುವ ಕರೆ 77KB ಗಿಂತಲೂ ದೊಡ್ಡ JSON ಡಾಕ್ಯುಮೆಂಟ್ ಆಗಿದೆ, ಇದು Wio ಟರ್ಮಿನಲ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದಕ್ಕೆ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ. ಬರೆಯುವ ಸಮಯದಲ್ಲಿ, ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯಲ್ಲಿ 215 ಧ್ವನಿಗಳು ಇವೆ, ಪ್ರತೀ ಒಂದು ಕೆಳಗಿನಂತ 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 ಟರ್ಮಿನಲ್ ನಿಂದ ಕರೆ ಮಾಡಬಹುದು. ನಿಮ್ಮ ಕೋಡ್ ನಂತರ ಪಟ್ಟಿಯಿಂದ ಸೂಕ್ತ ಧ್ವನಿಯೊಂದನ್ನು (ಹಾಗಾದರೆ ಮೊದಲನೆಯದನ್ನು) ಆಯ್ಕೆ ಮಾಡಬಹುದು.

ಕಾರ್ಯ - ಧ್ವನಿಗಳ ಪಟ್ಟಿ ಪಡೆಯಲು ಸರ್ವರ್ ರಹಿತ ಫಂಕ್ಷನನ್ನು ರಚಿಸಿ

VS Code ನಲ್ಲಿ ನಿಮ್ಮ smart-timer-trigger ಪ್ರಾಜೆಕ್ಟ್ ತೆರೆಯಿರಿ ಮತ್ತು ಟರ್ಮಿನಲ್ ತೆರೆಯಿರಿ ಮತ್ತು ವರ್ಚುಯಲ್ ಪರಿಸರ ಸಕ್ರಿಯವಾಗಿದೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಇಲ್ಲದಿದ್ದರೆ, ಟರ್ಮಿನಲ್ ನವನ್ನು ಕೊಲ್ಲಿಸಿ ಮರು ಸೃಷ್ಟಿಸಿ.
local.settings.json ಫೈಲನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಧ್ವನಿ API ಕೀ ಮತ್ತು ಸ್ಥಳಕ್ಕಾಗಿ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಸೇರಿಸಿ:
```
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
<key> ಅನ್ನು ನಿಮ್ಮ ಧ್ವನಿ ಸೇವೆ ಸಂಪನ್ಮೂಲವಿನ API ಕೀ ಇವು ಮರ್ಮಬಲಕರಿಸಿ. <location> ಅನ್ನು ನೀವು ಧ್ವನಿ ಸೇವೆ ಸಂಪನ್ಮೂಲವನ್ನು ಸೃಷ್ಟಿಸಿದ ಸ್ಥಳದಿಂದ ಬದಲಾಯಿಸಿ.
ಈ ಆಪ್ ಗೆ get-voices ಹೆಸರಿನ HTTP ಟ್ರಿಗರ್ ಅನ್ನು הבאರುವಿಕೆ ಸ್ನೇಹಪೂರ್ಣ ಕೆಳಗಿನ ಆಜ್ಞೆಯ ಬಳಸಿ VS Code ಟರ್ಮಿನಲ್‌ನಿಂದ ಫಂಕ್ಷನ್ಸ್ ಆಪ್ root ಫೋಲ್ಡರ್‌ನೊಳಗೆ:
```
func new --name get-voices --template "HTTP trigger"
```
ಇದು get-voices ಎಂಬ HTTP ಟ್ರಿಗರ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.
get-voices ಫೋಲ್ಡರ್‌ನಲ್ಲಿನ __init__.py ಫೈಲಿನ ವಿಷಯವನ್ನು ಕೆಳಗಿನಂತಾಗಿ ಬದಲಿ ಮಾಡಿ:
```
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 ಡಾಕ್ಯುಮೆಂಟು ಆಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಯುಎಸ್ ಧ್ವನಿಗಳಿಗಾಗಿಯು ಇದು 408 ಬೈಟ್ಸ್ ಮಾತ್ರ.
ನಿಮ್ಮ ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಚಲಿಸಲಾಗಿಸಿ. ನಂತರ ನೀವು curl ಮುಂತಾದ ಸಾಧನ ಬಳಸಿ ಅದನ್ನು ಪ್ರಯೋಗಿಸಬಹುದು, ನೀವು ನಿಮ್ಮ text-to-timer HTTP ಟ್ರಿಗರ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಿದ ರೀತಿಯಲ್ಲಿ. ನಿಮ್ಮ ಭಾಷೆಯನ್ನು JSON ದೇಹವಾಗಿ ಕಳುಹಿಸಿ:
```
{
    "language":"<language>"
}
```
<language> ಅನ್ನು ನಿಮ್ಮ ಭಾಷೆಯೊಂದಿಗೆ ಬದಲಾಯಿಸಿ, ಉದಾಹರಣೆಗೆ en-GB, ಅಥವಾ zh-CN.

💁 ನೀವು ಈ ಕೋಡ್ ಅನ್ನು code-spoken-response/functions ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಕಂಡುಹಿಡಿಯಬಹುದು.

ಕಾರ್ಯ - ನಿಮ್ಮ Wio ಟರ್ಮಿನಲ್ ನಿಂದ ಧ್ವನಿಯನ್ನು ಸಂಗ್ರಹಿಸಿ

ನಿಮ್ಮ smart-timer ಪ್ರಾಜೆಕ್ಟ್ VS Code ನಲ್ಲಿ ತೆರೆಯಿರಿ, ಇದುವರೆಗೆ ತೆರೆಯದಿದ್ದರೆ.
config.h ಹೆಡರ್ ಫೈಲ್ ತೆರೆಯಿರಿ ಮತ್ತು ನಿಮ್ಮ ಫಂಕ್ಷನ್ಸ್ ಆಪ್ URL ಅನ್ನು ಸೇರಿಸಿ:
```
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
<URL> ಅನ್ನು ನಿಮ್ಮ get-voices HTTP ಟ್ರಿಗರ್ URL ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ. ಇದು TEXT_TO_TIMER_FUNCTION_URL ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ, ಆದರೆ text-to-timer ಬದಲು get-voices ಎಂಬ ಫಂಕ್ಷನ್ ಹೆಸರಿರುತ್ತದೆ.
src ಫೋಲ್ಡರ್‌ನಲ್ಲಿ text_to_speech.h ಎಂಬ ಹೊಸ ಫೈಲ್ ಸೃಷ್ಟಿಸಿ. ಇದು ಪಠ್ಯದಿಂದ ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸಲು ಒಂದು ಕ್ಲಾಸ್ ವ್ಯಾಖ್ಯಾನ ಮಾಡಲು ಉಪಯೋಗಿಸಬಹುದು.

ಹೊಸ text_to_speech.h ಫೈಲ್ ಮೇಲ್ಭಾಗಕ್ಕೆ ಕೆಳಗಿನ ಇನ್‌ಕುಡ್ ನಿರ್ದೇಶನಗಳನ್ನು ಸೇರಿಸಿ:

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

ಇದರ ಕೆಳಗೆ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸಿ TextToSpeech ಕ್ಲಾಸ್ ಘೋಷಿಸುವುದಕ್ಕಾಗಿ ಮತ್ತು ಉಳಿದ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಬಳಸಬಹುದಾದ ಒಂದು ಇನ್ಸ್ಟಾನ್ಸ್:
```
class TextToSpeech
{
public:
private:
};

TextToSpeech textToSpeech;
```
ನಿಮ್ಮ ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಕರೆ ಮಾಡಲು, ನೀವು WiFi ಕ್ಲೈಂಟ್ ಘೋಷಿಸಬೇಕು. ಇದನ್ನು ಕ್ಲಾಸ್ private ವಿಭಾಗಕ್ಕೆ ಸೇರಿಸಿ:
```
WiFiClient _client;
```
private ವಿಭಾಗದಲ್ಲಿ, ಆಯ್ಕೆಮಾಡಲಾದ ಧ್ವನಿಗಾಗಿ ಒಂದು ಕ್ಷೇತ್ರವನ್ನು ಸೇರಿಸಿ:
```
String _voice;
```
public ವಿಭಾಗಕ್ಕೆ, ಮೊದಲ ಧ್ವನಿಯನ್ನು ಪಡೆಯಲು init ಫಂಕ್ಷನ್ ಸೇರಿಸಿ:
```
void init()
{
}
```
ಧ್ವನಿಗಳನ್ನು ಪಡೆಯಲು, JSON ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಗೆ ಭಾಷೆ ಜೊತೆಗೆ ಕಳುಹಿಸಬೇಕು. ಇದಕ್ಕಾಗಿ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು init ಫಂಕ್ಷನ್ಗೆ ಸೇರಿಸಿ:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;

String body;
serializeJson(doc, body);
```
ನಂತರ HTTPClient ಸೃಷ್ಟಿಸಿ, ಅದನ್ನು ಬಳಸಿಕೊಂಡು JSON ಡಾಕ್ಯುಮೆಂಟ್ ಪೋಸ್ಟ್ ಮಾಡಿ ಮತ್ತು ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಗೆ ಕರೆ ಮಾಡಿ:
```
HTTPClient httpClient;
httpClient.begin(_client, GET_VOICES_FUNCTION_URL);

int httpResponseCode = httpClient.POST(body);
```

ಈ ಕೆಳಗೆ ಪ್ರತಿಕ್ರಿಯೆಯ ಕೋಡ್ ಪರಿಶೀಲಿಸಿ, ಇದು 200 (ಯಶಸ್ಸು) ಅಂದರೆ ಧ್ವನಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆದು, ಪಟ್ಟಿಯಿಂದ ಮೊದಲ ಧ್ವನಿಯನ್ನು ತಗೆದು:

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

ನಂತರ HTTP ಕ್ಲೈಂಟ್ ಸಂಪರ್ಕ ಮುಗಿಸಿ:
```
httpClient.end();
```
main.cpp ಫೈಲ್ ತೆರೆಯಿರಿ, ಮತ್ತು ಈ ಹೊಸ ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರ್ಪಡೆ ಮಾಡಲು ಮೇಲ್ಭಾಗದಲ್ಲಿ ಕೆಳಗಿನ ಇನ್‌ಕುಡ್ ನಿರ್ದೇಶನ ಸೇರಿಸಿ:
```
#include "text_to_speech.h"
```
setup ಫಂಕ್ಷನಿನಲ್ಲಿ speechToText.init(); ಕರೆ ಕೆಳಗೆ TextToSpeech ಕ್ಲಾಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
```
textToSpeech.init();
```

ಈ ಕೋಡ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಿ, ನಿಮ್ಮ Wio ಟರ್ಮಿನಲ್ ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಸೀರಿಯಲ್ ಮಾನಿಟರ್ ಮೂಲಕ ಪರೀಕ್ಷಿಸಿ. ನಿಮ್ಮ ಫಂಕ್ಶನ್ಸ್ ಆಪ್ ಚಲಿಸುತ್ತಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ನೀವು ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ನಿಂದ ಲಭ್ಯವಿರುವ ಧ್ವನಿಗಳ ಪಟ್ಟಿಯನ್ನು ಮತ್ತು ಆಯ್ಕೆಮಾಡಲಾದ ಧ್ವನಿಯನ್ನು ಕಾಣಬಹುದು.

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

ಪಠ್ಯವನ್ನು ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸಿ

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

💁 ಈ ಪ್ರಾಜೆಕ್ಟಿನ ಹಿಂದಿನ ಪಾಠಗಳಲ್ಲಿ, ನೀವು ಮೈಕ್ರೋಫೋನಿನಿಂದ ಬಂಧಿಸಲಾಗಿರುವ ಧ್ವನಿಯನ್ನು ಫ್ಲಾಷ್ ಸ್ಮೃತಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದ್ದು. ಈ ಪಾಠದಲ್ಲಿ SD ಕಾರ್ಡ್ ಬಳಸಲಾಗಿದೆ ಏಕೆಂದರೆ Seeed ಧ್ವನಿ ಲೈಬ್ರರಿಗಳ ಮೂಲಕ ಅದರಿಂದ ಸೌಂಡ್ ಪ್ಲೇ ಮಾಡುವುದು ಸುಲಭ.

ಮತ್ತೊಂದು ಮಿತಿಯಾಗಿದೆ, ಧ್ವನಿ ಸೇವೆಯಿಂದ ಲಭ್ಯವಿರುವ ಆಡಿಯೋ ಡೇಟಾ ಮತ್ತು Wio ಟರ್ಮಿನಲ್ ಬೆಂಬಲಿಸುವ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು. ಸಂಪೂರ್ಣ ಕಂಪ್ಯೂಟರ್ ಗಳಿಗಿಂತ ವ್ಯತ್ಯಾಸವಾಗಿ, ಮೈಕ್ರೋಕಾರ್ಟ್ರೋರ್ಗೆ ಆಡಿಯೋ ಲೈಬ್ರರಿಗಳು ಬಹಳ ಮಿತಿತವಾಗಬಹುದು. ಉದಾಹರಣೆಗೆ, Seeed آر್ಡಿನೋ ಆಸುಡಿಯೋ ಲೈಬ್ರರಿ ReSpeaker ಮೀಡಿಯಂ Sound ಪ್ಲೇ ಮಾಡಲು ಫಿಕ್ಸ್ ಆಗಿ 44.1KHz ಸ್ಯಾಂಪಲ್ ರೇಟನ್ನು ಮಾತ್ರ ಬೆಂಬಲಿಸುತ್ತದೆ. Azure ಧ್ವನಿ ಸೇವೆಗಳು ಹಲವಾರು ಫಾರ್ಮ್ಯಾಟ್‌ಗಳಲ್ಲಿ ಆಡಿಯೋ ಒದಗಿಸುತ್ತವೆ, ಆದರೆ ಅವು 8KHz, 16KHz, 24KHz ಮತ್ತು 48KHz ಮಾತ್ರವನ್ನು ಮಾತ್ರ ಒದಗಿಸುತ್ತವೆ, 44.1KHz ಇಲ್ಲ. ಇದುವೇನಂದರೆ, ಆಡಿಯೋವನ್ನು 44.1KHz ಗೆ ಮರುಸ್ಯಾಂಪಲ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ಇದು Wio ಟರ್ಮಿನಲಿನ ಮೆಮೊರಿಯಲ್ಲಿ ಬಹಳ ಹೆಚ್ಚಿನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ಇಂತಹ ಮಾಹಿತಿಯನ್ನು ಸಂಸ್ಕರಿಸುವಾಗ, ಅದು ವೆಬ್ ಕರೆಗಳಿಂದ ಸುಳಿವಾಯಿತಾದರೆ, ಸರ್ವರ್ ರಹಿತ ಕೋಡ್ ಬಳಕೆಮಾಡುವುದು ಉತ್ತಮ. Wio ಟರ್ಮಿನಲ್ ಒಂದು ಸರ್ವರ್ ರಹಿತ ಫಂಕ್ಷನ್ ಅನ್ನು ಕರೆದೊಯ್ಯಬಹುದು, ಪರಿವರ್ತಿಸಲು ಪಠ್ಯವನ್ನು ನೀಡಬಹುದು, ಮತ್ತು ಆ ಸರ್ವರ್ ರಹಿತ ಫಂಕ್ಷನ್ ಧ್ವನಿ ಸೇವೆಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಪಠ್ಯವನ್ನು ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸಲು, ಜೊತೆಗೆ ಆಡಿಯೋವನ್ನು ಅಗತ್ಯ ಸ್ಯಾಂಪಲ್ ರೇಟಿಗೆ ಮರುಸ್ಯಾಂಪಲ್ ಮಾಡುತ್ತದೆ. ನಂತರ ಆಡಿಯೋವನ್ನು Wio ಟರ್ಮಿನಲ್ ಗೆ SD ಕಾರ್ಡಿನಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ ReSpeaker ಮೂಲಕ ಪ್ಲೇ ಮಾಡಲು ಸೂಕ್ತ ಆಕಾರದಲ್ಲಿ ಹಿಂತಿರುಗಿಸಬಹುದು.

ಕಾರ್ಯ - ಪಠ್ಯವನ್ನು ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸಲು ಸರ್ವರ್ ರಹಿತ ಫಂಕ್ಷನನ್ನು ರಚಿಸಿ

VS Code ನಲ್ಲಿ ನಿಮ್ಮ smart-timer-trigger ಪ್ರಾಜೆಕ್ಟ್ ತೆರೆಯಿರಿ, ಮತ್ತು ಟರ್ಮಿನಲ್ ತೆರೆಯಿರಿ, ವರ್ಚುಯಲ್ ಪರಿಸರ ಸಕ್ರಿಯವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಇಲ್ಲದಿದ್ದರೆ ಟರ್ಮಿನಲ್ ನವನ್ನು ಕೊಲ್ಲಿಸಿ ಮರು ಸೃಷ್ಟಿಸಿ.
ಈ ಆಪ್ ಗೆ text-to-speech ಹೆಸರಿನ ಹೊಸ HTTP ಟ್ರಿಗರ್ ಅನ್ನು VS Code ಟರ್ಮಿನಲ್ ನಿಂದ functions ಆಪ್ ಪ್ರಾಜೆಕ್ಟ್ ರೂಟ್ ಫೋಲ್ಡರ್‌ನೊಳಗಿಂದ ಕೆಳಗಿನ ಆಜ್ಞೆಯ ಬಳಸಿ ಸೇರಿಸಿ:
```
func new --name text-to-speech --template "HTTP trigger"
```
ಇದು text-to-speech ಎಂಬ HTTP ಟ್ರಿಗರ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.
librosa ಪಿಪ್ ಪ್ಯಾಕೇಜ್ ಆಡಿಯೋವನ್ನು ಮರುಸ್ಯಾಂಪಲ್ ಮಾಡಲು ಫಂಕ್ಷನ್ಗಳನ್ನು ಹೊಂದಿದೆ, ಅದನ್ನು requirements.txt ಫೈಲಿಗೆ ಸೇರಿಸಿ:
```
librosa
```
ಇದನ್ನು ಸೇರಿಸಿದ ನಂತರ, VS Code ಟರ್ಮಿನಲ್ ನಲ್ಲಿ ಕೆಳಗಿನ ಆಜ್ಞೆ ಮೂಲಕ ಪಿಪ್ ಪ್ಯಾಕೇಜ್ ಗಳು ಸ್ಥಾಪಿಸಿ:
```
pip install -r requirements.txt
```
⚠️ ನೀವು ಲಿನಕ್ಸನ್ನು, Raspberry Pi OS ಸೇರಿ ಬಳಸುತ್ತಿದ್ದರೆ, libsndfile ಅನ್ನು ಕೆಳಗಿನ ಆಜ್ಞೆಯಿಂದ ಸ್ಥಾಪಿಸಬೇಕಾಗಬಹುದು:
```
sudo apt update
sudo apt install libsndfile1-dev
```
ಪಠ್ಯವನ್ನು ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸಲು, ನೀವು ಧ್ವನಿ API ಕಿಯನ್ನು ನೇರವಾಗಿ ಬಳಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಬದಲಾಗಿ ಲಭ್ಯತಾಯನ್ನು ಹುಡುಕಲು, API ಕೀ ಬಳಸಿ ಅರ್ಜಿಯನ್ನು ಪ್ರಾಮಾಣೀಕರಿಸಬೇಕು. text-to-speech ಫೋಲ್ಡರ್ ನಲ್ಲಿರುವ __init__.py ಫೈಲ್ ತೆರೆದು ಇದರಲ್ಲಿ ಇರುವ ಎಲ್ಲಾ ಕೋಡನ್ನು ಕೆಳಗಿನಂತೆ ಬದಲಿ ಮಾಡಿ:
```
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 ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಇದು ಧ್ವನಿ ಸೇವೆಯ ಲಭ್ಯತಾ ಟೋಕನ್ ಪಡೆದುಕೊಳ್ಳುತ್ತದೆ.

ಈ ಕೋಡಿನ ಕೆಳಗೆ, ಕೆಳಗಿನಂತೆ ಸೇರಿಸಿ:

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 ರಚಿಸುತ್ತದೆ, ನಂತರ REST API ಗೆ ಲಭ್ಯತಾ ಟೋಕನ್ ಬಳಸಿ ಕರೆ ಮಾಡುತ್ತದೆ. ಈ REST API ಕರೆ 16-ಬಿಟ್, 48KHz ಮೋನೋ WAV ಫೈಲ್ ಆಗಿ ಎನ್‌ಕೋಡ್ ಮಾಡಿದ ಆಡಿಯೋವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದನ್ನು playback_format ಮೌಲ್ಯ ನಿಯಂತ್ರಿಸುತ್ತದೆ.

ನಂತರ librosa ಇದನ್ನು 48KHz ನಿಂದ 44.1KHz ಗೆ ಮರುಸ್ಯಾಂಪಲ್ ಮಾಡುತ್ತದೆ. ನಂತರ ಈ ಆಡಿಯೋವನ್ನು ಬೈನರಿ ಬಫರ್‌ಗೆ ಉಳಿಸಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ನಿಮ್ಮ ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಅಥವಾ ಕ್ಲೌಡ್ ನಲ್ಲಿ ನಿಯೋಜಿಸಿ. ನಂತರ ನೀವು curl ಮುಂತಾದ ಸಾಧನ ಬಳಸಿ ಅದನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು, ನಿಮ್ಮ text-to-timer HTTP ಟ್ರಿಗರ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಿದ ರೀತಿಯಲ್ಲಿ. JSON ದೇಹದಲ್ಲಿ ಭಾಷೆ, ಧ್ವನಿ ಮತ್ತು ಪಠ್ಯವನ್ನು ಕಳುಹಿಸಿ:
```
{
    "language": "<language>",
    "voice": "<voice>",
    "text": "<text>"
}
```
<language> ನ್ನು ನಿಮ್ಮ ಭಾಷೆಗೆ, ಉದಾಹರಣೆಗೆ en-GB ಅಥವಾ zh-CN ಗೆ ಬದಲಾಯಿಸಿ. <voice> ನೀವು ಉಪಯೋಗಿಸುವ ಧ್ವನಿಗೆ ಬದಲಾಯಿಸಿ. <text> ಪಠ್ಯವನ್ನು ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸುವುದಕ್ಕೆ ಬದಲಾಯಿಸಿ. ನೀವು ಔಟ್‌ಪುಟ್ ಅನ್ನು ಫೈಲ್ ಗೆ ಉಳಿಸಿ ಮತ್ತು ಯಾವುದಾದರೂ WAV ಫೈಲ್ ಪ್ಲೇ ಮಾಡುವ ಆಡಿಯೋ ಪ್ಲೇಯರ್ ಬಳಸಿ ಪ್ಲೇ ಮಾಡಬಹುದು.

ಉದಾಹರಣೆಗೆ, "Hello" ಅನ್ನು US ಇಂಗ್ಲಿಷ್ Jenny Neural ಧ್ವನಿಯನ್ನು ಉಪಯೋಗಿಸಿ ಧ್ವನಿಗೆ ಪರಿವರ್ತಿಸಲು, ಸ್ಥಳೀಯವಾಗಿ ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಚಲಿಸುತ್ತಿದ್ದಾಗ, ಕೆಳಗಿನ curl ಆಜ್ಞೆಯನ್ನು ಉಪಯೋಗಿಸಬಹುದು:
```
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 ಫೋಲ್ಡರ್‌ನಲ್ಲಾರೆ ಕಂಡುಹಿಡಿಯಬಹುದು.

ಕಾರ್ಯ - ನಿಮ್ಮ Wio ಟರ್ಮಿನಲ್ ರಿಂದ ಧ್ವನಿಯನ್ನು ಪಡೆಯಿರಿ

VS Code ನಲ್ಲಿ ನಿಮ್ಮ smart-timer ಪ್ರಾಜೆಕ್ಟ್ ತೆರೆಯಿರಿ, ಇದುವರೆಗೆ ತೆರೆಯದಿದ್ದರೆ.
config.h ಹೆಡರ್ ಫೈಲನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ನಿಮ್ಮ ಫಂಕ್ಷನ್ಸ್ ಆಪ್ URL ನ್ನು ಸೇರಿಸಿ:
```
const char *TEXT_TO_SPEECH_FUNCTION_URL = "<URL>";
```
<URL> ನ್ನು ನಿಮ್ಮ text-to-speech HTTP ಟ್ರಿಗರ್ URL ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ. ಇದು TEXT_TO_TIMER_FUNCTION_URL ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆ, ಆದರೆ ಫಂಕ್ಷನ್ ಹೆಸರನ್ನು text-to-speech ಇಡಬೇಕು.
text_to_speech.h ಹೆಡರ್ ಫೈಲನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು TextToSpeech ಕ್ಲಾಸ್ ನ public ವಿಭಾಗದಲ್ಲಿ ಕೆಳಗಿನ ಮೆಥಡ್‌ನ್ನು ಸೇರಿಸಿ:
```
void convertTextToSpeech(String text)
{
}
```
convertTextToSpeech ಮೆಥಡ್ ಗೆ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸಿ, ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಗೆ ಕಳುಹಿಸಬೇಕಾದ JSON ರಚಿಸಲು:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;
doc["voice"] = _voice;
doc["text"] = text;

String body;
serializeJson(doc, body);
```
ಇದು JSON ಡಾಕ್ಯುಮೆಂಟ್‌ಗೆ ಭಾಷೆ, ಧ್ವನಿ ಮತ್ತು ಪಠ್ಯವನ್ನು ಬರೆಯುತ್ತದೆ, ನಂತರ ಅದನ್ನು ಸ್ಟ್ರಿಂಗ್ ಗೆ ಸರಣಿಬದ್ಧಗೊಳಿಸುತ್ತದೆ.
ಇದರ ಕೆಳಗೆ, ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಕರೆ ಮಾಡಲು ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
```
HTTPClient httpClient;
httpClient.begin(_client, TEXT_TO_SPEECH_FUNCTION_URL);

int httpResponseCode = httpClient.POST(body);
```
ಇದು HTTPClient ಸೃಷ್ಟಿಸಿ, ನಂತರ JSON ಡಾಕ್ಯುಮೆಂಟ್ ಬಳಸಿ text-to-speech HTTP ಟ್ರಿಗರ್ ಗೆ POST ವಿನಂತಿ ಮಾಡುತ್ತದೆ.
ಕರೆ ಯಶಸ್ವಿಯಾದರೆ, ಫಂಕ್ಷನ್ಸ್ ಆಪ್ ಕರೆನಿಂದ ಹಿಂಪಡೆಯಲ್ಪಟ್ಟ ಬೈನರಿ ಡೇಟಾ ಅನ್ನು SD ಕಾರ್ಡ್ ನ ಫೈಲಿಗೆ ಸ್ಟ್ರೀಮ್ ಮಾಡಬಹುದು. ಇದಕ್ಕಾಗಿ ಕೆಳಗಿನ ಕೋಡ್ ಸೇರಿಸಿ:
```
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 ಎಂಬ ಫೈಲಿಗೆ ಸ್ಟ್ರೀಮ್ ಆಗುತ್ತದೆ.
ಈ ಮೆಥೋದಿನ ಕೊನೆಯಲ್ಲಿ HTTP ಸಂಪರ್ಕ ಮುಗಿಸಿ:
```
httpClient.end();
```
ಈಗ ಮಾತನಾಡಲಾಗುವ ಪಠ್ಯವನ್ನು ಧ್ವನಿಯಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು. main.cpp ಫೈಲ್‌ನಲ್ಲಿ, ಪಠ್ಯವನ್ನು ಮಾತನಾಡಿಸಲು ಪರಿವರ್ತಿಸಲು say ಕಾರ್ಯದ ಅಂತ್ಯಕ್ಕೆ ಕೆಳಗಿನ ಸಾಲನ್ನು ಸೇರಿಸಿ:
```
textToSpeech.convertTextToSpeech(text);
```

ಕಾರ್ಯ - ನಿಮ್ಮ Wio Terminal ನಿಂದ ಧ್ವನಿ ವಾಜಿಸುವುದು

ತುಂಬಾ ಶೀಘ್ರದಲ್ಲಿದೆ

ನಿಮ್ಮ functions ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕ್ಲೌಡಿಗೆ ಜಾರಿಮಾಡುವುದು

ಫಂಕ್ಷನ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಚಾಲನೆ ಮಾಡುವ ಕಾರಣವೆಂದರೆ ಲಿನಕ್ಸ್ನಲ್ಲಿ ಇರುವ librosa ಪಿಪ್ ಪ್ಯಾಕೇಜ್ ಒಂದು ಡಿಪೆಂಡೆನ್ಸಿಯುಳ್ಳ ಲೈಬ್ರರಿಯನ್ನು ಅವಲಂಬಿಸಿದೆ, ಅದು ಡೀಫಾಲ್್ಟ್ ಆಗಿ ಸ್ಥಾಪಿಸಲಾಗಿಲ್ಲ ಮತ್ತು ಫಂಕ್ಷನ್ ಅಪ್ಲಿಕೇಶನ್ ಚಾಲನೆಗೊಳ್ಳುವ ಮೊದಲು ಆ ಲೈಬ್ರರಿಯನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ. ಫಂಕ್ಷನ್ ಅಪ್ಲಿಕೇಶನ್ಗಳು ಸರ್ವರ್ ರಹಿತವಾಗಿದ್ದು - ನೀವು ಆ ಸರ್ವರ್‌ಗಳನ್ನು ನಿಮ್ಮಿಂದ ನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ಆ ಲೈಬ್ರರಿಯನ್ನು ಮುಂಚಿತವಾಗಿ ಸ್ಥಾಪಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಇದರಿಂದ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವುದು, ಡೋಕರ್ನಲ್ಲಿ ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಅಪ್ಲಿಕೇಶನನ್ನು ಜಾರಿಮಾಡುವುದಾಗಿದೆ. ಈ ಡೋಕರ್ ಕಂಟೈನ್‌ರ್ ಅನ್ನು ಕ್ಲೌಡ್ ಸೇವೆ ಬಳಸುವಾಗ ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಅಪ್ಲಿಕೇಶನ್‌ನ ಹೊಸ ನಕಲನ್ನು ಸಲಿಸಬೇಕಾದಾಗ ಚಲಾಯಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ ಅವಶ್ಯಕತೆ ಲಭ್ಯ ಸಂಪನ್ಮೂಲಗಳಿಂದ ಮೀರಿದಾಗ, ಅಥವಾ ಅಪ್ಲಿಕೇಶನ್ ಬಳಸಿಲ್ಲದೇ ಮುಗಿದಾಗ).

ನೀವು ಫಂಕ್ಷನ್ ಅಪ್ಲಿಕೇಶನನ್ನು ಸ್ಥಾಪಿಸುವ ಮತ್ತು ಡೋಕರ್ ಮೂಲಕ ಜಾರಿಮಾಡುವುದಕ್ಕೆ ಸೂಚನೆಗಳನ್ನು Microsoft Docs ನಲ್ಲಿ ಲಿನಕ್ಸ್ನಲ್ಲಿ ಕಸ್ಟಮ್ ಕಂಟೈನರ್ ಬಳಸಿ ಫಂಕ್ಷನ್ ನಿರ್ಮಿಸುವ ದಾಖಲೆ ನಲ್ಲಿ ಕಾಣಬಹುದು.

ಇದನ್ನು ಜಾರಿಮಾಡಿದ ನಂತರ, ನೀವು ನಿಮ್ಮ Wio Terminal ಕೋ드를 ಈ ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಸಂಪರ್ಕಿಸಲು ಪೋರ್ಟ್ ಮಾಡಬಹುದು:

config.h ಗೆ Azure Functions ಪ್ರಮಾಣಪತ್ರವನ್ನು ಸೇರಿಸಿ:

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

<WiFiClient.h> ನ ಎಲ್ಲಾ ಇನ್‌ಕ್ಲೂಡ್ ಗಳನ್ನು <WiFiClientSecure.h> ಗೆ ಬದಲಿಸಿ.
ಎಲ್ಲಾ WiFiClient ಎಲಗಳನ್ನು WiFiClientSecure ಗೆ ಬದಲಿಸಿ.
WiFiClientSecure ಎಲವನ್ನು ಹೊಂದಿರುವ ಪ್ರತಿಯೊಂದು ಕ್ಲಾಸ್‌ನಲ್ಲಿ ಒಂದು ನಿರ್ಮಿತಿಕಾರಕ (constructor) ಸೇರಿಸಿ ಮತ್ತು ಆ ನಿರ್ಮಿತಿಕಾರಕದಲ್ಲಿ ಪ್ರಮಾಣಪತ್ರವನ್ನು ಸೆಟ್ ಮಾಡಿ:
```
_client.setCACert(FUNCTIONS_CERTIFICATE);
```

ಒಪ್ಪಿಗೆಯ ಮನವಿ:
ಈ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು AI ಅನುವಾದ ಸೇವೆ Co-op Translator ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ಶುದ್ಧತೆಯಲ್ಲಿಂದು ಪ್ರಯತ್ನಿಸುವರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ದೋಷಗಳು ಅಥವಾ ತಪ್ಪುತೆಗಳಿರಬಹುದೆಂದನ್ನು ದಯವಿಟ್ಟು ಗಮನದಲ್ಲಿರಿಸಿಕೊಳ್ಳಿ. ಮೂಲ ಭಾಷೆಯ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಅಧಿಕೃತ ಮತ್ತು ನಂಬಿಕೆಯುತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಲಾಗಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದ ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದವನ್ನು ಬಳಸಿ ಉಂಟಾಗುವ ಯಾವುದೇ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ದುರ್ವುಳಿಕೆಗಳು ಅಥವಾ ವ್ಯಾಖ್ಯಾನಾತ್ಮಕ ತಪ್ಪುಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.

40 KiB Raw Permalink Blame History