23 KiB

Raw Permalink Blame History

Beszéd szöveggé alakítása - Wio Terminal

Ebben a lecke részben kódot fogsz írni, amely a rögzített hangban lévő beszédet szöveggé alakítja a beszédfelismerő szolgáltatás segítségével.

Küldd el a hangot a beszédfelismerő szolgáltatásnak

A hangot a REST API segítségével lehet elküldeni a beszédfelismerő szolgáltatásnak. A szolgáltatás használatához először hozzáférési tokent kell kérned, majd ezt a tokent használva érheted el a REST API-t. Ezek a hozzáférési tokenek 10 perc után lejárnak, ezért a kódodnak rendszeresen új tokent kell kérnie, hogy mindig naprakész legyen.

Feladat - hozzáférési token kérése

Nyisd meg a smart-timer projektet, ha még nincs megnyitva.

Add hozzá a következő könyvtárfüggőségeket a platformio.ini fájlhoz a WiFi eléréséhez és a JSON kezeléséhez:

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

Add hozzá a következő kódot a config.h fejlécfájlhoz:
```
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";
```
Cseréld ki a <SSID> és <PASSWORD> helyére a WiFi-hez tartozó megfelelő értékeket.

Cseréld ki az <API_KEY> helyére a beszédfelismerő szolgáltatás erőforrásának API kulcsát. Az <LOCATION> helyére pedig azt a helyet, amelyet a beszédfelismerő szolgáltatás erőforrás létrehozásakor használtál.

Az <LANGUAGE> helyére add meg annak a nyelvnek a helyi beállítását, amelyen beszélni fogsz, például en-GB angolhoz vagy zn-HK kantonihoz. A támogatott nyelvek és helyi beállítások listáját megtalálod a Microsoft dokumentációjában a nyelv- és hangtámogatásról.

A TOKEN_URL konstans a token kiadó URL-je hely nélkül. Ezt később kombináljuk a helyszínnel, hogy megkapjuk a teljes URL-t.

Ahogy a Custom Vision-hoz való csatlakozásnál, itt is HTTPS kapcsolatot kell használnod a token kiadó szolgáltatáshoz való csatlakozáshoz. Add hozzá a következő kódot a config.h végéhez:

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

Ez ugyanaz a tanúsítvány, amelyet a Custom Vision-hoz való csatlakozáskor használtál.

Add hozzá a WiFi fejlécfájl és a config fejlécfájl beillesztését a main.cpp fájl tetejéhez:
```
#include <rpcWiFi.h>

#include "config.h"
```

Adj hozzá kódot a WiFi-hez való csatlakozáshoz a main.cpp fájlban a setup függvény fölé:

void connectWiFi()
{
    while (WiFi.status() != WL_CONNECTED)
    {
        Serial.println("Connecting to WiFi..");
        WiFi.begin(SSID, PASSWORD);
        delay(500);
    }

    Serial.println("Connected!");
}

Hívd meg ezt a függvényt a setup függvényben, miután a soros kapcsolat létrejött:
```
connectWiFi();
```
Hozz létre egy új fejlécfájlt a src mappában speech_to_text.h néven. Ebben a fejlécfájlban add hozzá a következő kódot:
```
#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;
```
Ez tartalmazza a szükséges fejlécfájlokat egy HTTP kapcsolat létrehozásához, a konfigurációt és a mic.h fejlécfájlt, valamint definiál egy SpeechToText nevű osztályt, mielőtt deklarálná az osztály egy példányát, amelyet később használhatsz.
Add hozzá a következő két mezőt az osztály private szekciójához:
```
WiFiClientSecure _token_client;
String _access_token;
```
Az _token_client egy WiFi kliens, amely HTTPS-t használ, és a hozzáférési token megszerzésére szolgál. Ez a token azután az _access_token mezőben lesz tárolva.

Add hozzá a következő metódust az osztály private szekciójához:

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

Ez a kód összeállítja a token kiadó API URL-jét a beszéderőforrás helyének felhasználásával. Ezután létrehoz egy HTTPClient-et a webkéréshez, amelyet úgy állít be, hogy a WiFi klienssel használja a token végpont tanúsítványát. Az API kulcsot fejlécben állítja be a híváshoz. Ezután POST kérést küld a tanúsítvány megszerzéséhez, és hiba esetén újrapróbálkozik. Végül visszaadja a hozzáférési tokent.

Add hozzá a következő metódust az osztály public szekciójához a hozzáférési token megszerzéséhez. Erre a későbbi leckékben lesz szükség a szöveg beszéddé alakításához.
```
String AccessToken()
{
    return _access_token;
}
```
Add hozzá az init metódust az osztály public szekciójához, amely beállítja a token klienst:
```
void init()
{
    _token_client.setCACert(TOKEN_CERTIFICATE);
    _access_token = getAccessToken();
}
```
Ez beállítja a tanúsítványt a WiFi kliensen, majd megszerzi a hozzáférési tokent.
A main.cpp fájlban add hozzá ezt az új fejlécfájlt a beillesztési direktívákhoz:
```
#include "speech_to_text.h"
```
Inicializáld a SpeechToText osztályt a setup függvény végén, a mic.init hívás után, de mielőtt a Ready kiírásra kerülne a soros monitorra:
```
speechToText.init();
```

Feladat - hang olvasása a flash memóriából

A lecke korábbi részében a hangot a flash memóriába rögzítetted. Ezt a hangot el kell küldeni a Beszédfelismerő REST API-nak, ezért ki kell olvasni a flash memóriából. Nem lehet egy memóriapufferbe betölteni, mert túl nagy lenne. Az HTTPClient osztály, amely REST hívásokat végez, képes adatokat streamelni egy Arduino Stream segítségével - egy olyan osztály, amely kis darabokban tud adatokat betölteni, és ezeket a darabokat egyenként küldi el a kérés részeként. Minden alkalommal, amikor meghívod a read metódust egy streamen, az visszaadja a következő adatblokkot. Egy Arduino stream hozható létre, amely képes olvasni a flash memóriából. Hozz létre egy új fájlt flash_stream.h néven a src mappában, és add hozzá a következő kódot:
```
#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:

};
```
Ez deklarálja a FlashStream osztályt, amely az Arduino Stream osztályából származik. Ez egy absztrakt osztály - a származtatott osztályoknak néhány metódust implementálniuk kell, mielőtt az osztály példányosítható lenne, és ezek a metódusok ebben az osztályban vannak definiálva.

✅ További információ az Arduino Streamekről az Arduino Stream dokumentációjában
Add hozzá a következő mezőket az osztály private szekciójához:
```
size_t _pos;
size_t _flash_address;
const sfud_flash *_flash;

byte _buffer[HTTP_TCP_BUFFER_SIZE];
```
Ez definiál egy ideiglenes puffert az adatok tárolására, amelyeket a flash memóriából olvasott ki, valamint mezőket a jelenlegi pozíció tárolására az olvasás során, a flash memória aktuális címére, és a flash memória eszközére.
Az osztály private szekciójában add hozzá a következő metódust:
```
void populateBuffer()
{
    sfud_read(_flash, _flash_address, HTTP_TCP_BUFFER_SIZE, _buffer);
    _flash_address += HTTP_TCP_BUFFER_SIZE;
    _pos = 0;
}
```
Ez a kód a flash memória aktuális címéről olvas, és az adatokat egy pufferbe tárolja. Ezután növeli a címet, így a következő hívás a memória következő blokkját olvassa. A puffer mérete az alapján van meghatározva, hogy mekkora a legnagyobb darab, amelyet az HTTPClient egyszerre küldhet a REST API-nak.

💁 A flash memória törlését a szemcseméret alapján kell elvégezni, az olvasás viszont nem.
Az osztály public szekciójában adj hozzá egy konstruktort:
```
FlashStream()
{
    _pos = 0;
    _flash_address = 0;
    _flash = sfud_get_device_table() + 0;

    populateBuffer();
}
```
Ez a konstruktor beállítja az összes mezőt, hogy a flash memória blokk elejéről kezdjen olvasni, és betölti az első adatblokkot a pufferbe.
Implementáld a write metódust. Ez a stream csak adatokat olvas, így ez nem csinál semmit, és 0-t ad vissza:
```
virtual size_t write(uint8_t val)
{
    return 0;
}
```
Implementáld a peek metódust. Ez visszaadja az aktuális pozíción lévő adatot anélkül, hogy a stream előrehaladna. A peek többszöri meghívása mindig ugyanazt az adatot adja vissza, amíg nem olvasol adatot a streamből.
```
virtual int peek()
{
    return _buffer[_pos];
}
```
Implementáld az available függvényt. Ez visszaadja, hogy hány bájt olvasható a streamből, vagy -1-et, ha a stream véget ért. Ebben az osztályban a maximálisan elérhető adat nem lehet nagyobb, mint az HTTPClient darabmérete. Ha több adat érhető el, mint a darabméret, akkor a darabméretet adja vissza. Ha kevesebb, akkor az elérhető adatot adja vissza. Ha az összes adatot streamelték, -1-et ad vissza.
```
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;
}
```
Implementáld a read metódust, hogy visszaadja a következő bájtot a pufferből, növelve a pozíciót. Ha a pozíció meghaladja a puffer méretét, betölti a következő blokkot a flash memóriából a pufferbe, és visszaállítja a pozíciót.
```
virtual int read()
{
    int retVal = _buffer[_pos++];

    if (_pos == HTTP_TCP_BUFFER_SIZE)
    {
        populateBuffer();
    }

    return retVal;
}
```
A speech_to_text.h fejlécfájlban adj hozzá egy beillesztési direktívát ehhez az új fejlécfájlhoz:
```
#include "flash_stream.h"
```

Feladat - a beszéd szöveggé alakítása

A beszéd szöveggé alakítható, ha a hangot elküldöd a Beszédfelismerő REST API-nak. Ez a REST API más tanúsítványt használ, mint a token kiadó, ezért add hozzá a következő kódot a config.h fejlécfájlhoz, hogy definiáld ezt a tanúsítványt:

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

Adj hozzá egy konstansot ehhez a fájlhoz a beszéd URL-jéhez hely nélkül. Ezt később kombináljuk a helyszínnel és a nyelvvel, hogy megkapjuk a teljes URL-t.
```
const char *SPEECH_URL = "https://%s.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=%s";
```
A speech_to_text.h fejlécfájlban, a SpeechToText osztály private szekciójában definiálj egy mezőt egy WiFi klienshez, amely a beszéd tanúsítványt használja:
```
WiFiClientSecure _speech_client;
```
Az init metódusban állítsd be a tanúsítványt ezen a WiFi kliensen:
```
_speech_client.setCACert(SPEECH_CERTIFICATE);
```
Add hozzá a következő kódot a SpeechToText osztály public szekciójához, hogy definiálj egy metódust a beszéd szöveggé alakításához:
```
String convertSpeechToText()
{

}
```
Add hozzá a következő kódot ehhez a metódushoz, hogy létrehozz egy HTTP klienst a beszéd tanúsítvánnyal konfigurált WiFi klienssel, és a beszéd URL-jével, amely a helyszínnel és a nyelvvel van beállítva:
```
char url[128];
sprintf(url, SPEECH_URL, SPEECH_LOCATION, LANGUAGE);

HTTPClient httpClient;
httpClient.begin(_speech_client, url);
```

Néhány fejlécet be kell állítani a kapcsolaton:

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

Ez beállítja a fejlécet az engedélyezéshez a hozzáférési tokennel, az audio formátumhoz a mintavételi frekvenciával, és azt, hogy az ügyfél JSON formátumban várja az eredményt.

Ezután add hozzá a következő kódot a REST API hívás végrehajtásához:

Serial.println("Sending speech...");

FlashStream stream;
int httpResponseCode = httpClient.sendRequest("POST", &stream, BUFFER_SIZE);

Serial.println("Speech sent!");

Ez létrehoz egy FlashStream-et, és ezt használja az adatok streamelésére a REST API-nak.

Ezután add hozzá a következő kódot:

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

Ez a kód ellenőrzi a válaszkódot.

Ha 200, ami a siker kódja, akkor az eredményt lekéri, JSON-ból dekódolja, és a DisplayText tulajdonságot beállítja a text változóba. Ez az a tulajdonság, amelyben a beszéd szöveges változata visszatér.

Ha a válaszkód 401, akkor a hozzáférési token lejárt (ezek a tokenek csak 10 percig érvényesek). Új hozzáférési tokent kér, és újra végrehajtja a hívást.

Egyébként hibát küld a soros monitorra, és a text üres marad.

Add hozzá a következő kódot ennek a metódusnak a végéhez, hogy bezárd a HTTP klienst, és visszaadd a szöveget:
```
httpClient.end();

return text;
```
A main.cpp fájlban hívd meg ezt az új convertSpeechToText metódust a processAudio függvényben, majd írd ki a beszédet a soros monitorra:
```
String text = speechToText.convertSpeechToText();
Serial.println(text);
```

Fordítsd le ezt a kódot, töltsd fel a Wio Terminal eszközödre, és teszteld a soros monitoron keresztül. Amint a Ready megjelenik a soros monitoron, nyomd meg a C gombot (a bal oldali, legközelebb a bekapcsoló kapcsolóhoz), és beszélj. 4 másodpercnyi hangot rögzít, majd szöveggé alakítja.

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

💁 Ezt a kódot megtalálod a code-speech-to-text/wio-terminal mappában.

😀 A beszéd szöveggé alakító programod sikeres volt!

Felelősség kizárása:
Ez a dokumentum az AI fordítási szolgáltatás, a Co-op Translator segítségével lett lefordítva. Bár törekszünk a pontosságra, kérjük, vegye figyelembe, hogy az automatikus fordítások hibákat vagy pontatlanságokat tartalmazhatnak. Az eredeti dokumentum az eredeti nyelvén tekintendő hiteles forrásnak. Kritikus információk esetén javasolt professzionális emberi fordítást igénybe venni. Nem vállalunk felelősséget semmilyen félreértésért vagy téves értelmezésért, amely a fordítás használatából eredhet.

23 KiB Raw Permalink Blame History