24 KiB

Raw Permalink Blame History Unescape Escape

Metinden Sese - Wio Terminal

Bu dersin bu bölümünde, metni sese dönüştürerek sesli geri bildirim sağlayacaksınız.

Metinden Sese

Bir önceki derste konuşmayı metne dönüştürmek için kullandığınız konuşma hizmetleri SDK'sı, metni tekrar sese dönüştürmek için de kullanılabilir.

Ses Listesi Almak

Konuşma talep ederken, kullanılacak sesi belirtmeniz gerekir çünkü konuşma, çeşitli farklı sesler kullanılarak oluşturulabilir. Her dil, farklı seslerden oluşan bir yelpazeyi destekler ve her dil için desteklenen seslerin listesini konuşma hizmetleri SDK'sından alabilirsiniz. Ancak, mikrodenetleyicilerin sınırlamaları burada devreye giriyor - metinden sese hizmetleri tarafından desteklenen seslerin listesini almak için yapılan çağrı, 77KB'den büyük bir JSON belgesidir ve bu, Wio Terminal tarafından işlenemeyecek kadar büyüktür. Yazım sırasında, tam liste 215 ses içeriyor ve her biri aşağıdaki gibi bir JSON belgesiyle tanımlanıyor:

{
    "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"
}

Bu JSON, birden fazla ses stiline sahip olan Aria sesi içindir. Metni sese dönüştürürken gereken tek şey, en-US-AriaNeural gibi kısa isimdir.

Bu listenin tamamını mikrodenetleyicinize indirip çözümlemek yerine, kullandığınız dil için ses listesini almak ve bunu Wio Terminal'den çağırmak için biraz daha sunucusuz kod yazmanız gerekecek. Kodunuz daha sonra listedeki uygun bir sesi, örneğin bulduğu ilk sesi seçebilir.

Görev - Ses Listesi Almak için Sunucusuz Bir Fonksiyon Oluşturun

VS Code'da smart-timer-trigger projenizi açın ve sanal ortamın etkinleştirildiğinden emin olarak terminali açın. Değilse, terminali kapatıp yeniden oluşturun.
local.settings.json dosyasını açın ve konuşma API anahtarı ve konumu için ayarları ekleyin:
```
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
<key> kısmını konuşma hizmeti kaynağınızın API anahtarıyla değiştirin. <location> kısmını ise konuşma hizmeti kaynağını oluşturduğunuz konumla değiştirin.
Bu uygulamaya get-voices adında yeni bir HTTP tetikleyici eklemek için, VS Code terminalinde fonksiyon uygulaması projesinin kök klasöründen aşağıdaki komutu çalıştırın:
```
func new --name get-voices --template "HTTP trigger"
```
Bu, get-voices adında bir HTTP tetikleyici oluşturacaktır.

get-voices klasöründeki __init__.py dosyasının içeriğini aşağıdakiyle değiştirin:

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)

Bu kod, sesleri almak için bir HTTP isteği yapar. Bu ses listesi, tüm diller için sesleri içeren büyük bir JSON bloğudur, bu nedenle istek gövdesinde iletilen dil için sesler filtrelenir, ardından kısa isim çıkarılır ve bir JSON listesi olarak döndürülür. Metni sese dönüştürmek için gereken değer kısa isimdir, bu nedenle yalnızca bu değer döndürülür.

💁 Gerekirse, yalnızca istediğiniz sesleri seçmek için filtreyi değiştirebilirsiniz.

Bu, verilerin boyutunu yazım sırasında 77KB'den, çok daha küçük bir JSON belgesine indirir. Örneğin, ABD sesleri için bu 408 bayttır.

Fonksiyon uygulamanızı yerel olarak çalıştırın. Daha sonra bunu, text-to-timer HTTP tetikleyicinizi test ettiğiniz gibi bir araç (örneğin curl) kullanarak çağırabilirsiniz. Dilinizi bir JSON gövdesi olarak ilettiğinizden emin olun:
```
{
    "language":"<language>"
}
```
<language> kısmını dilinizle değiştirin, örneğin en-GB veya zh-CN.

💁 Bu kodu code-spoken-response/functions klasöründe bulabilirsiniz.

Görev - Wio Terminal'inizden Sesi Alın

smart-timer projenizi VS Code'da açın (henüz açık değilse).
config.h başlık dosyasını açın ve fonksiyon uygulamanızın URL'sini ekleyin:
```
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
<URL> kısmını, fonksiyon uygulamanızdaki get-voices HTTP tetikleyicisinin URL'siyle değiştirin. Bu, TEXT_TO_TIMER_FUNCTION_URL değeriyle aynı olacaktır, ancak text-to-timer yerine get-voices fonksiyon adını içerecektir.
src klasöründe text_to_speech.h adında yeni bir dosya oluşturun. Bu, metni sese dönüştürmek için bir sınıf tanımlamak için kullanılacaktır.

Yeni text_to_speech.h dosyasının en üstüne aşağıdaki include yönergelerini ekleyin:

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

Bu yönergelerin altına, uygulamanın geri kalanında kullanılabilecek bir örnekle birlikte TextToSpeech sınıfını bildiren aşağıdaki kodu ekleyin:
```
class TextToSpeech
{
public:
private:
};

TextToSpeech textToSpeech;
```
Fonksiyon uygulamanızı çağırmak için bir WiFi istemcisi bildirmeniz gerekir. Sınıfın private bölümüne aşağıdakileri ekleyin:
```
WiFiClient _client;
```
private bölümüne, seçilen ses için bir alan ekleyin:
```
String _voice;
```
public bölümüne, ilk sesi alacak bir init fonksiyonu ekleyin:
```
void init()
{
}
```
Sesleri almak için, dile sahip bir JSON belgesinin fonksiyon uygulamasına gönderilmesi gerekir. Bu JSON belgesini oluşturmak için init fonksiyonuna aşağıdaki kodu ekleyin:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;

String body;
serializeJson(doc, body);
```

Ardından bir HTTPClient oluşturun ve JSON belgesini göndererek fonksiyon uygulamasını çağırın:

HTTPClient httpClient;
httpClient.begin(_client, GET_VOICES_FUNCTION_URL);

int httpResponseCode = httpClient.POST(body);

Bunun altına, yanıt kodunu kontrol eden ve eğer 200 (başarılı) ise ses listesini çıkaran, listeden ilk sesi alan kodu ekleyin:

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

Bunun ardından, HTTP istemci bağlantısını sonlandırın:
```
httpClient.end();
```
main.cpp dosyasını açın ve bu yeni başlık dosyasını dahil etmek için en üste aşağıdaki include yönergesini ekleyin:
```
#include "text_to_speech.h"
```
setup fonksiyonunda, speechToText.init(); çağrısının altına, TextToSpeech sınıfını başlatmak için aşağıdakileri ekleyin:
```
textToSpeech.init();
```

Bu kodu derleyin, Wio Terminal'inize yükleyin ve seri monitör üzerinden test edin. Fonksiyon uygulamanızın çalıştığından emin olun.

Fonksiyon uygulamasından döndürülen mevcut seslerin listesini ve seçilen sesi göreceksiniz.

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

Metni Sese Dönüştürmek

Kullanılacak bir ses elde ettikten sonra, bu ses metni sese dönüştürmek için kullanılabilir. Sesleri dönüştürürken aynı bellek sınırlamaları geçerlidir, bu nedenle ses, ReSpeaker üzerinden çalınmak üzere SD karta yazılmalıdır.

💁 Bu projedeki önceki derslerde, mikrofondan alınan konuşmayı depolamak için flash bellek kullandınız. Bu ders, Seeed ses kütüphanelerini kullanarak SD karttan ses çalmanın daha kolay olması nedeniyle bir SD kart kullanır.

Dikkate alınması gereken başka bir sınırlama daha vardır: konuşma hizmetinden alınan mevcut ses verileri ve Wio Terminal'in desteklediği formatlar. Tam bilgisayarların aksine, mikrodenetleyiciler için ses kütüphaneleri destekledikleri ses formatlarında çok sınırlı olabilir. Örneğin, ReSpeaker üzerinden ses çalabilen Seeed Arduino Audio kütüphanesi yalnızca 44.1KHz örnekleme hızında sesi destekler. Azure konuşma hizmetleri bir dizi formatta ses sağlayabilir, ancak bunların hiçbiri bu örnekleme hızını kullanmaz; yalnızca 8KHz, 16KHz, 24KHz ve 48KHz sağlar. Bu, sesin 44.1KHz'ye yeniden örneklenmesi gerektiği anlamına gelir; bu, özellikle bellek açısından Wio Terminal'in sahip olduğundan daha fazla kaynağa ihtiyaç duyar.

Bu tür verileri manipüle etmeniz gerektiğinde, özellikle veri bir web çağrısı yoluyla alınıyorsa, sunucusuz kod kullanmak genellikle daha iyidir. Wio Terminal, dönüştürülecek metni ileten bir sunucusuz fonksiyonu çağırabilir ve sunucusuz fonksiyon hem konuşma hizmetini çağırarak metni sese dönüştürebilir hem de sesi gerekli örnekleme hızına yeniden örnekleyebilir. Daha sonra sesi, Wio Terminal'in SD karta kaydetmesi ve ReSpeaker üzerinden çalması için gereken formatta döndürebilir.

Görev - Metni Sese Dönüştürmek için Sunucusuz Bir Fonksiyon Oluşturun

VS Code'da smart-timer-trigger projenizi açın ve sanal ortamın etkinleştirildiğinden emin olarak terminali açın. Değilse, terminali kapatıp yeniden oluşturun.
Bu uygulamaya text-to-speech adında yeni bir HTTP tetikleyici eklemek için, VS Code terminalinde fonksiyon uygulaması projesinin kök klasöründen aşağıdaki komutu çalıştırın:
```
func new --name text-to-speech --template "HTTP trigger"
```
Bu, text-to-speech adında bir HTTP tetikleyici oluşturacaktır.
librosa Pip paketi, sesi yeniden örneklemek için işlevlere sahiptir, bu nedenle bunu requirements.txt dosyasına ekleyin:
```
librosa
```
Eklendikten sonra, VS Code terminalinden aşağıdaki komutu kullanarak Pip paketlerini yükleyin:
```
pip install -r requirements.txt
```
⚠️ Linux, Raspberry Pi OS dahil, kullanıyorsanız, aşağıdaki komutla libsndfile yüklemeniz gerekebilir:
```
sudo apt update
sudo apt install libsndfile1-dev
```

Metni sese dönüştürmek için, konuşma API anahtarını doğrudan kullanamazsınız; bunun yerine, bir erişim jetonu talep etmeniz gerekir. Bu talep, API anahtarını kullanarak kimlik doğrulaması yapar. text-to-speech klasöründeki __init__.py dosyasını açın ve içindeki tüm kodu aşağıdakiyle değiştirin:

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)

Bu, ayarlardan okunacak konum ve konuşma anahtarı için sabitler tanımlar. Daha sonra, konuşma hizmeti için bir erişim jetonu alacak get_access_token fonksiyonunu tanımlar.

Bu kodun altına aşağıdakileri ekleyin:

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)

Bu, metni sese dönüştüren HTTP tetikleyiciyi tanımlar. Dönüştürülecek metni, dili ve sesi istekle gönderilen JSON gövdesinden çıkarır, konuşmayı talep etmek için biraz SSML oluşturur ve ardından erişim jetonunu kullanarak ilgili REST API'yi çağırır. Bu REST API çağrısı, 16-bit, 48KHz mono WAV dosyası olarak kodlanmış sesi döndürür; bu, playback_format değerine göre REST API çağrısına gönderilir.

Daha sonra bu ses, librosa tarafından 48KHz örnekleme hızından 44.1KHz örnekleme hızına yeniden örneklenir ve ardından bu ses, döndürülen bir ikili tamponda saklanır.

Fonksiyon uygulamanızı yerel olarak çalıştırın veya buluta dağıtın. Daha sonra bunu, text-to-timer HTTP tetikleyicinizi test ettiğiniz gibi bir araç (örneğin curl) kullanarak çağırabilirsiniz. Dil, ses ve metni JSON gövdesi olarak ilettiğinizden emin olun:
```
{
    "language": "<language>",
    "voice": "<voice>",
    "text": "<text>"
}
```
<language> kısmını dilinizle değiştirin, örneğin en-GB veya zh-CN. <voice> kısmını kullanmak istediğiniz sesle değiştirin. <text> kısmını ise sese dönüştürmek istediğiniz metinle değiştirin. Çıktıyı bir dosyaya kaydedebilir ve WAV dosyalarını çalabilen herhangi bir ses oynatıcıyla çalabilirsiniz.

Örneğin, "Hello" kelimesini ABD İngilizcesi ile Jenny Neural sesi kullanarak sese dönüştürmek için, fonksiyon uygulaması yerel olarak çalışırken aşağıdaki curl komutunu kullanabilirsiniz:
```
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"
     }'
```
Bu, sesi hello.wav olarak geçerli dizine kaydedecektir.