# വാചകം ശബ്ദത്തിലേക്ക് - Wio ടെർമിനൽ

പാഠത്തിന്റേതിന്റെ ഈ ഭാഗത്തിൽ, നിങ്ങൾ സംസാരിച്ചു നൽകുന്ന പ്രതികരണത്തിനായി വാചകത്തെ ശബ്ദത്തിലേക്ക് മാറ്റും.

## വാചകം ശബ്ദത്തിലേക്ക്

കഴിഞ്ഞ പാഠത്തിൽ നിങ്ങൾ ചെലുത്തിയ ശബ്ദം വാചകത്തിലേക്ക് മാറ്റാൻ ഉപയോഗിച്ചുവന്ന പ്രസവ സേവനങ്ങള്‍ SDK, വാചകത്തിനെ തിരിച്ചു ശബ്ദത്തിലേക്ക് മാറ്റാനും ഉപയോഗിക്കാവുന്നതാണ്.

## ശബ്ദങ്ങളുടെ പട്ടിക നേടുക

ശബ്ദം അഭ്യർത്ഥിക്കുമ്പോൾ, വ്യത്യസ്ത ശബ്ദങ്ങൾ ഉപയോഗിച്ച് പ്രസവം സൃഷ്ടിക്കാനാകുമെന്ന് കൊണ്ടു ഉപയോഗിക്കേണ്ട ശബ്ദം നൽകേണ്ടതുണ്ട്. ഓരോ ഭാഷക്കും വ്യത്യസ്ത ശബ്ദങ്ങൾ പിന്തുടരുന്നുണ്ട്, നിങ്ങൾക്കു ഓരോ ഭാഷയ്ക്കും പിന്തുണയുള്ള ശബ്ദങ്ങളുടെ പട്ടിക പ്രസവ സേവനങ്ങളുടെ SDK-യിൽ നിന്ന് ലഭിക്കും. മൈക്രോകൺട്രോളറുകളുടെ പരിധികൾ ഇവിടെ ബാധകമാണ് - വാചകം ശബ്ദത്തിലേക്ക് സേവനങ്ങൾ പിന്തുണക്കുന്ന ശബ്ദങ്ങളുടെ പട്ടിക ലഭിക്കുന്ന കോൾ ഒരു JSON ഡോക്യുമെന്റ് ആണ്, 77KB-ൽകൂടുതലായ വലിപ്പമുള്ളത്, 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-ൽ തുറക്കുക, ടർമിനൽ തുറന്ന് virtual environment പ്രവർത്തനക്ഷമമെന്ന് ഉറപ്പാക്കുക. അല്ലെങ്കിൽ, ടർമിനൽ കൊളയും പുനഃസൃഷ്ടിക്കയും ചെയ്യുക.

1. `local.settings.json` ഫയൽ തുറന്ന് പ്രസവ API കീയും ലൊക്കേഷനും ചേർക്കുക:

    ```json
    "SPEECH_KEY": "<key>",
    "SPEECH_LOCATION": "<location>"
    ```

    `<key>` എന്നതും പ്രസവ സേവന റിസോഴ്സ് API കീ യുമായി മാറ്റുക. `<location>` പ്രസവ സേവന റിസോഴ്സ് സൃഷ്ടിക്കുമ്പോൾ ഉപയോഗിച്ച ലൊക്കേഷൻ ഉപയോഗിക്കുക.

1. ഈ ആപ്പിലേക്ക് `get-voices` എന്ന പുതിയ HTTP ട്രിഗ്ഗർ താഴെപോലെ VS Code ടർമിനലിൽ functions ആപ് പ്രോജക്റ്റിന്റെ റൂട്ടിൽ നിന്നും സൃഷ്ടിക്കുക:

    ```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 ഡോക്യുമെന്റായി മാറ്റുന്നു. ഉദാഹരണത്തിന്, യു.എസ് ശബ്ദങ്ങൾക്കു 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 ഡോക്യുമെന്റ് ഫംഗ്ഷൻസ് ആപ്പിലേക്ക് ഭാഷയുമായി അയയ്ക്കേണ്ടതുണ്ട്. ഇങ്ങനെ JSON നിർമ്മിക്കുന്ന കോഡ് `init` ഫംഗ്ഷനിൽ ചേർക്കുക:

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

## വാചകം ശബ്ദത്തിലേക്ക് മാറ്റുക

ഒരു ശബ്ദം ലഭിച്ചശേഷം, അത് ഉപയോഗിച്ച് വാചകത്തെ ശബ്ദത്തിലേക്ക് മാറ്റാം. ശബ്ദങ്ങളിലെ സ്മൃതിമാരണപരിധികളും വാചകത്തെ ശബ്ദത്തിലേക്ക് മാറ്റുമ്പോൾ ബാധകമാണ്, അതിനാൽ ശബ്ദം SD കാർഡിൽ എഴുതേണ്ടതാണ്, പിന്നീട് ReSpeaker ഉപയോഗിച്ചായി പ്ലേ ചെയ്യാം.

> 💁 ഈ പ്രോജക്ടിലെ മുൻപത്തെ പാഠങ്ങളിൽ മൈക്രോഫോണിൽ നിന്ന് പിടിച്ച ശബ്ദം സ്റ്റോബ് ചെയ്യാൻ ഫ്ലാഷ് മെമ്മറി ഉപയോഗിച്ചിരുന്നു. ഈ പാഠത്തിൽ SD കാർഡ് ഉപയോഗിക്കുന്നു കാരണം Seeed ഓഡിയോ ലൈബ്രറികൾ വഴി അതിൽ നിന്നുള്ള ശബ്ദം കളിക്കുക എളുപ്പമാണ്.

മറ്റൊരു പരിധി പരിഗണിക്കേണ്ടത് പ്രസവ സേവനത്തിലെ ലഭ്യമായ ഓഡിയോ ഡാറ്റയും Wio ടെർമിനൽ പിന്തുടരുന്ന ഫോർമാറ്റുകളും ആണ്. പൂർണ്ണ കമ്പ്യൂട്ടറുകളെപ്പോലെ, മൈക്രോകൺട്രോളറുകൾക്കുള്ള ഓഡിയോ ലൈബ്രറികൾ സഹായിക്കുന്ന ഓഡിയോ ഫോർമാറ്റുകൾ വളരെ പരിമിതമാണ്. ഉദാഹരണത്തിന്, ReSpeaker വഴി ശബ്ദം പ്ലേ ചെയ്യുന്നതിന് Seeed Arduino Audio ലൈബ്രറി മാത്രമേ 44.1KHz സാമ്പിൾ റേറ്റിൽ ഓഡിയോ പിന്തുണയ്ക്കാറുളളൂ. Azure പ്രസവ സേവനങ്ങൾ വിവിധ ഫോർമാറ്റുകളിൽ ഓഡിയോ നൽകാൻ കഴിയും, പക്ഷേ 44.1KHz അല്ല, 8KHz, 16KHz, 24KHz, 48KHz മാത്രമേ നൽകുന്നുള്ളൂ. അതിനാൽ 44.1KHz-ലേക്ക് ഓഡിയോ റീസാമ്പിൾ ചെയ്യേണ്ടിവരും, ഇത് Wio ടെർമினലിന് ആവശ്യമായ കൂടുതൽ റിസോഴ്‌സുകൾ, പ്രത്യേകിച്ച് മെമ്മറി ആവശ്യമായതാണ്.

ഇത്തരമൊരു ഡാറ്റ മാനിപുലേഷൻ ആവശ്യമുള്ളപ്പോൾ, ഇത് സർവർലെസ് കോഡ് ഉപയോഗിക്കുന്നത് നല്ല മാർഗ്ഗമാണ്, പ്രത്യേകിച്ച് ഡാറ്റ വെബ് കോൾ വഴിയാണ് ലഭിക്കുന്നത് എന്നു കണക്കിലെടുത്താൽ. Wio ടെർമിനൽ സർവർലെസ് ഫംഗ്ഷൻ കോൾ ചെയ്ത് വാചകം നൽകുകയും, ഫംഗ്ഷൻ കോഡ് പ്രസവ സേവനം ഉപയോഗിച്ച് വാചകത്തെ ശബ്ദത്തിലേക്ക് മാറ്റുകയും, ഓഡിയോ ആവശ്യമുള്ള സാമ്പിൾ റേറ്റിലേക്ക് റീസാമ്പിൾ ചെയുകയും ചെയ്തശേഷം വേണം SD കാർഡിൽ സൂക്ഷിക്കുകയും ReSpeaker വഴി പ്ലേ ചെയ്യാനും കഴിയും.

### ടാസ്‌ക് - വാചകം ശബ്ദത്തിലേക്ക് മാറ്റാൻ സർവർലെസ് ഫങ്ഷൻ സൃഷ്ടിക്കുക

1. നിങ്ങളുടെ `smart-timer-trigger` പ്രോജക്‌റ്റ് VS Code-ൽ തുറന്ന് ടർമിനൽ വെർച്വൽ എൻവയോൺമെന്റ് പ്രവർത്തനക്ഷമമെന്ന് ഉറപ്പാക്കുക. അല്ലെങ്കിൽ ടർമിനൽ കൊളയും പുനഃസൃഷ്ടിയുമാകട്ടെ.

1. ഈ ആപ്പിലേക്ക് `text-to-speech` എന്ന പുതിയ HTTP ട്രിഗർ സൃഷ്ടിക്കാൻ VS Code ടർമിനലിൽ functions ആപ് ഫോള്ഡറിന്റെ റൂട്ടിൽ താഴെ കൊടുത്ത കമാൻഡ് ഉപയോഗിക്കുക:

    ```sh
    func new --name text-to-speech --template "HTTP trigger"
    ```

    ഇത് `text-to-speech` എന്ന HTTP ട്രിഗ്ഗർ സൃഷ്ടിക്കും.

1. [librosa](https://librosa.org) പിപ്പ് പാക്കേജിൽ ഓഡിയോ റീസാമ്പിങ് ഫംഗ്ഷനുകൾ ഉണ്ട്, അതിനാൽ `requirements.txt` ഫയലിൽ ഇത് ചേർക്കുക:

    ```sh
    librosa
    ```

    ഇത് ചേർത്തശേഷം VS Code ടർമിനലിൽ താഴെ കൊടുത്ത കമാൻഡ് ഉപയോഗിച്ച് പിപ്പ് പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക:

    ```sh
    pip install -r requirements.txt
    ```

    > ⚠️ ലിനക്സ്, Raspberry Pi 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)
    ```

    ഇത് സജ്ജീകരണങ്ങളിൽ നിന്നു location, speech key അംഗീകരിക്കുന്ന ഘടകങ്ങൾ നിർവചിക്കുന്നു. തുടർന്ന് പ്രസവ സേവനത്തിനായി ആക്സസ് ടോക്കൺ എടുക്കുന്ന `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 സൃഷ്ടിച്ച് പ്രസവം അഭ്യർത്ഥിക്കുന്നു, ആകെയുള്ള REST API ആക്സസ് ടോക്കൺ ഉപയോഗിച്ച് പ്രാമാണീകരിക്കുന്നു. ഈ REST API 16-ബിറ്റ്, 48KHz മോനോ WAV ഫയൽ ആയി കോഡ് ചെയ്ത ഓഡിയോ തിരികെ നൽകുന്നു, `playback_format` മൂല്യത്തിന്റെ അടിസ്ഥാനത്തിൽ ഇത് REST API-യിൽ സജ്ജീകരിച്ചിരിക്കുന്നു.

    പിന്നീട് `librosa` ഉപയോഗിച്ച് 48KHz-ൽ നിന്നു 44.1KHz ആയി റീസാമ്പിൾ ചെയ്തു, ഈ ഓഡിയോ ബൈനറി ബഫറിൽ സേവ് ചെയ്ത് തിരിച്ചയയ്‌ക്കുന്നു.

1. നിങ്ങളുടെ ഫംഗ്ഷൻസ് ആപ് ലൊക്കലായി ഓടിക്കുക അല്ലെങ്കിൽ ക്ലൗഡിലേക്ക് ഡിപ്ലോയു ചെയ്യുക. പിന്നെ curl പോലുള്ള ടൂൾ ഉപയോഗിച്ച് ഇത് ആഡ് ചെയ്യുന്ന പോലെ ടെസ്റ്റ് ചെയ്യാം. ഭാഷ, ശബ്ദം, വാചകം JSON ബോഡിയായി പാസ്സ്ജിയ്ക്കാൻ ശ്രദ്ധിക്കുക:

    ```json
    {
        "language": "<language>",
        "voice": "<voice>",
        "text": "<text>"
    }
    ```

    `<language>`-ന് പകരം നിങ്ങളുടെ ഭാഷ നൽകുക (ഉദാഹരണം: `en-GB`, `zh-CN`), `<voice>`-ക്ക് നിങ്ങളുടെ ഇഷ്ടപ്പെട്ട ശബ്ദം, `<text>`-ന് പകരം ശബ്ദമാക്കേണ്ട വാചകം നൽകുക. ഔട്ട്‌പുട്ട് ഫയലായി സംരക്ഷിച്ച് WAV പ്ലെയറുമായി പ്ലേ ചെയ്യാം.

    ഉദാഹരണത്തിന്, "Hello" വാചകം US ഇംഗ്ലീഷ് Jenny Neural ശബ്ദത്തിൽ ശബ്ദമാക്കി ലൊക്കലായി റൺ ചെയ്യുന്ന ഫംഗ്ഷൻസ് ആപ് വഴി ഇത് കോൾ ചെയ്യാൻ 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` പ്രോജക്ട് VS Code-ൽ തുറന്നിട്ടില്ലെങ്കിൽ തുറക്കുക.

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 ഡോക്യുമെന്റ് പോസ്റ്റ് ചെയ്ത് വാചകം ശബ്ദത്തിലേക്ക് HTTP ട്രിഗർ കോൾ ചെയ്യുന്നു.

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 Terminal-ൽ നിന്ന് ഓഡിയോ പ്ലേ ചെയ്യുക

**വരും ദിവസം**

## നിങ്ങളുടെ functions അപ്ലിക്കേഷൻ ക്ളൗഡിൽ വിന്യസിക്കൽ

functions അപ്ലിക്കേഷൻ ലൊക്കലായി ഓടിക്കാൻ കാരണം, ലിനക്സിൽ `librosa` പൈപ് പാക്കേജിന് ഒരു ഡിപ്പെൻഡൻസി ഉണ്ടു, അത് ഡിഫാൾട്ട് ആയി ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ല, ഫങ്ഷൻ അപ്ലിക്കേഷൻ ഓടിക്കുന്നതിന് മുൻപ് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട്. ഫങ്ഷൻ അപ്ലിക്കേഷനുകൾ സേർവർലെസ് ആണു - നിങ്ങളുടെതന്നെയാണ് സേർവർകളെ നിയന്ത്രിക്കാൻ കഴിയാത്തത്, അതിനാൽ ഈ ലൈബ്രറി മുൻകൂട്ടി ഇൻസ്റ്റാൾ ചെയ്യാനുള്ള വഴിയില്ല.

ഇത് ചെയ്യാനുള്ള മാർഗം, Docker കണ്ടെയ്നർ ഉപയോഗിച്ച് functions അപ്ലിക്കേഷൻ വിന്യസിക്കൽ ആണ്. പുതിയ ഇൻസ്റ്റൻസ് വേണ്ടുമ്പോൾ ക്ളൗഡാണ് ഈ കണ്ടെയ്നർ വിന്യസിക്കുന്നത് (ഉദാഹരണത്തിന് ആവശ്യങ്ങൾ ലഭ്യമായ വിഭവങ്ങളെക്കാൾ കൂടുതലായാൽ, അല്ലെങ്കിൽ functions അപ്ലിക്കേഷൻ സാധാരണ കാലയളവിനുപിന്നാലെ അടച്ചിടുമ്പോൾ).

ഫങ്ഷൻ അപ്ലിക്കേഷൻ സജ്ജമാക്കി Docker വഴി വിന്യസിക്കുന്നതിന് നിർദേശങ്ങൾ നിങ്ങൾക്ക് ലഭ്യമാണ് [create a function on Linux using a custom container documentation on Microsoft Docs](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 Terminal കോഡ് ഈ function ആക്സസ് ചെയ്യാൻ പോർട്ട് ചെയ്യാം:

1. Azure Functions സർടിഫിക്കറ്റ് `config.h`-യിൽ ചേർക്കുക:

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