21 KiB

Raw Permalink Blame History

Kõne tekstiks - Wio Terminal

Selles õppetunni osas kirjutad koodi, et muuta salvestatud heli kõne tekstiks, kasutades kõneteenust.

Saada heli kõneteenusele

Heli saab saata kõneteenusele REST API kaudu. Kõneteenuse kasutamiseks tuleb esmalt taotleda juurdepääsutokenit ja seejärel kasutada seda tokenit REST API-le juurdepääsuks. Need juurdepääsutokenid aeguvad 10 minuti pärast, seega peaks sinu kood neid regulaarselt uuendama, et need oleksid alati ajakohased.

Ülesanne - juurdepääsutokeni hankimine

Ava projekt smart-timer, kui see pole veel avatud.

Lisa platformio.ini faili järgmised teegisõltuvused, et pääseda WiFi-le ja käsitleda JSON-i:

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

Lisa config.h päisefaili järgmine kood:
```
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";
```
Asenda <SSID> ja <PASSWORD> vastavate väärtustega oma WiFi jaoks.

Asenda <API_KEY> oma kõneteenuse ressursi API võtmega. Asenda <LOCATION> asukohaga, mida kasutasid kõneteenuse ressursi loomisel.

Asenda <LANGUAGE> keele lokaadi nimega, milles räägid, näiteks en-GB inglise keele jaoks või zn-HK kantoni keele jaoks. Saad toetatud keelte ja nende lokaadi nimede loendi Microsofti dokumentatsioonist keele ja hääle toe kohta.

TOKEN_URL konstant on tokeni väljastaja URL ilma asukohata. See kombineeritakse hiljem asukohaga, et saada täielik URL.

Nagu Custom Visioniga ühenduse loomisel, pead kasutama HTTPS-ühendust, et ühendada tokeni väljastamise teenusega. Lisa config.h faili lõppu järgmine kood:

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

See on sama sertifikaat, mida kasutasid Custom Visioniga ühenduse loomisel.

Lisa main.cpp faili algusesse WiFi päisefaili ja config päisefaili kaasamine:
```
#include <rpcWiFi.h>

#include "config.h"
```

Lisa kood WiFi-ga ühenduse loomiseks main.cpp faili setup funktsiooni kohale:

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

    Serial.println("Connected!");
}

Kutsu see funktsioon välja setup funktsioonis pärast seda, kui seeriaühendus on loodud:
```
connectWiFi();
```
Loo src kausta uus päisefail nimega speech_to_text.h. Lisa sellesse päisefaili järgmine kood:
```
#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;
```
See sisaldab vajalikke päisefaile HTTP-ühenduse, konfiguratsiooni ja mic.h päisefaili jaoks ning defineerib klassi nimega SpeechToText, enne kui deklareerib selle klassi eksemplari, mida saab hiljem kasutada.
Lisa selle klassi private sektsiooni järgmised kaks välja:
```
WiFiClientSecure _token_client;
String _access_token;
```
_token_client on WiFi klient, mis kasutab HTTPS-i ja mida kasutatakse juurdepääsutokeni hankimiseks. See token salvestatakse _access_token-i.

Lisa private sektsiooni järgmine meetod:

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

See kood koostab URL-i tokeni väljastaja API jaoks, kasutades kõneressursi asukohta. Seejärel loob HTTPClient veebipäringu tegemiseks, seadistades selle kasutama WiFi klienti, mis on konfigureeritud tokeni lõpppunkti sertifikaadiga. API võti määratakse päringu päisesse. Seejärel tehakse POST-päring sertifikaadi hankimiseks, proovides uuesti, kui ilmnevad vead. Lõpuks tagastatakse juurdepääsutoken.

Lisa public sektsiooni meetod juurdepääsutokeni hankimiseks. Seda on vaja hilisemates õppetundides teksti kõneks muutmiseks.
```
String AccessToken()
{
    return _access_token;
}
```
Lisa public sektsiooni init meetod, mis seadistab tokeni kliendi:
```
void init()
{
    _token_client.setCACert(TOKEN_CERTIFICATE);
    _access_token = getAccessToken();
}
```
See määrab sertifikaadi WiFi kliendile ja seejärel hangib juurdepääsutokeni.
Lisa main.cpp faili uus päisefail kaasamisdirektiivide hulka:
```
#include "speech_to_text.h"
```
Initsialiseeri SpeechToText klass setup funktsiooni lõpus, pärast mic.init väljakutset, kuid enne kui Ready kirjutatakse seeriamonitori:
```
speechToText.init();
```

Ülesanne - heli lugemine välkmälust

Õppetunni varasemas osas salvestati heli välkmällu. See heli tuleb saata kõneteenuse REST API-le, seega tuleb see välkmälust lugeda. Seda ei saa laadida mälupuhvrisse, kuna see oleks liiga suur. HTTPClient klass, mis teeb REST-päringuid, saab andmeid voogesitada, kasutades Arduino Streami - klassi, mis saab andmeid väikeste tükkidena laadida ja saata need ükshaaval päringu osana. Iga kord, kui kutsutakse read voogesituse puhul, tagastatakse järgmine andmeplokk. Arduino voogesitus saab luua, et lugeda välkmälust. Loo src kausta uus fail nimega flash_stream.h ja lisa sellesse järgmine kood:
```
#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:

};
```
See deklareerib FlashStream klassi, mis pärineb Arduino Stream klassist. See on abstraktne klass - pärandklassid peavad rakendama mõned meetodid enne, kui klassi saab instantsida, ja need meetodid on selles klassis määratletud.

✅ Loe rohkem Arduino voogesituse kohta Arduino Stream dokumentatsioonist
Lisa private sektsiooni järgmised väljad:
```
size_t _pos;
size_t _flash_address;
const sfud_flash *_flash;

byte _buffer[HTTP_TCP_BUFFER_SIZE];
```
See määratleb ajutise puhvri, et salvestada andmeid, mis on loetud välkmälust, koos väljadega, mis salvestavad praeguse positsiooni puhvrist lugemisel, praeguse aadressi välkmälust lugemiseks ja välkmälu seadme.
Lisa private sektsiooni järgmine meetod:
```
void populateBuffer()
{
    sfud_read(_flash, _flash_address, HTTP_TCP_BUFFER_SIZE, _buffer);
    _flash_address += HTTP_TCP_BUFFER_SIZE;
    _pos = 0;
}
```
See kood loeb välkmälust praegusel aadressil ja salvestab andmed puhvris. Seejärel suurendab aadressi, nii et järgmine väljakutse loeb järgmise mäluploki. Puhvri suurus põhineb suurimal tükil, mida HTTPClient REST API-le korraga saadab.

💁 Välkmälu kustutamine tuleb teha terasuuruse järgi, lugemine seevastu ei pea.
Lisa selle klassi public sektsiooni konstruktor:
```
FlashStream()
{
    _pos = 0;
    _flash_address = 0;
    _flash = sfud_get_device_table() + 0;

    populateBuffer();
}
```
See konstruktor seadistab kõik väljad, et alustada lugemist välkmälu ploki algusest, ja laadib esimese andmeploki puhvris.
Rakenda write meetod. See voogesitus loeb ainult andmeid, seega see ei tee midagi ja tagastab 0:
```
virtual size_t write(uint8_t val)
{
    return 0;
}
```
Rakenda peek meetod. See tagastab andmed praegusel positsioonil, liigutamata voogesitust edasi. peek korduv väljakutsumine tagastab alati samad andmed, kui voogesitusest pole andmeid loetud.
```
virtual int peek()
{
    return _buffer[_pos];
}
```
Rakenda available funktsioon. See tagastab, kui palju baite saab voogesitusest lugeda, või -1, kui voogesitus on lõppenud. Selle klassi puhul on maksimaalne saadav suurus mitte rohkem kui HTTPClienti tüki suurus. Kui voogesitust kasutatakse HTTP kliendis, kutsub see funktsiooni, et näha, kui palju andmeid on saadaval, ja seejärel taotleb nii palju andmeid, et saata REST API-le. Me ei taha, et iga tükk oleks suurem kui HTTP kliendi tüki suurus, seega kui rohkem on saadaval, tagastatakse tüki suurus. Kui vähem, siis tagastatakse saadaval olev suurus. Kui kõik andmed on voogesitatud, tagastatakse -1.
```
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;
}
```

Rakenda read meetod, et tagastada järgmine bait puhvrist, suurendades positsiooni. Kui positsioon ületab puhvri suuruse, täidetakse puhver järgmise plokiga välkmälust ja positsioon lähtestatakse.

virtual int read()
{
    int retVal = _buffer[_pos++];

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

    return retVal;
}

Lisa speech_to_text.h päisefaili kaasamisdirektiiv selle uue päisefaili jaoks:
```
#include "flash_stream.h"
```

Ülesanne - kõne tekstiks muutmine

Kõne saab tekstiks muuta, saates heli kõneteenuse REST API-le. Selle REST API-l on erinev sertifikaat kui tokeni väljastajal, seega lisa config.h päisefaili järgmine kood, et määratleda see sertifikaat:

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

Lisa sellele failile konstant kõne URL-i jaoks ilma asukohata. See kombineeritakse hiljem asukoha ja keelega, et saada täielik URL.

const char *SPEECH_URL = "https://%s.stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1?language=%s";

speech_to_text.h päisefailis, SpeechToText klassi private sektsioonis, defineeri väli WiFi kliendi jaoks, mis kasutab kõne sertifikaati:
```
WiFiClientSecure _speech_client;
```
init meetodis määra sertifikaat sellele WiFi kliendile:
```
_speech_client.setCACert(SPEECH_CERTIFICATE);
```
Lisa SpeechToText klassi public sektsiooni järgmine kood, et defineerida meetod kõne tekstiks muutmiseks:
```
String convertSpeechToText()
{

}
```
Lisa sellele meetodile järgmine kood, et luua HTTP klient, kasutades WiFi klienti, mis on konfigureeritud kõne sertifikaadiga, ja kasutades kõne URL-i, mis on määratud asukoha ja keelega:
```
char url[128];
sprintf(url, SPEECH_URL, SPEECH_LOCATION, LANGUAGE);

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

Mõned päised tuleb ühendusel määrata:

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

See määrab päised autoriseerimiseks, kasutades juurdepääsutokenit, audio formaati, kasutades näidissagedust, ja määrab, et klient ootab tulemust JSON-is.

Pärast seda lisa järgmine kood REST API päringu tegemiseks:

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

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

Serial.println("Speech sent!");

See loob FlashStream ja kasutab seda andmete voogesitamiseks REST API-le.

Selle alla lisa järgmine kood:

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

See kood kontrollib vastusekoodi.

Kui see on 200, mis on edukuse kood, siis tulemus hangitakse, dekodeeritakse JSON-ist ja DisplayText omadus määratakse text muutujasse. See on omadus, milles kõne tekstiversioon tagastatakse.

Kui vastusekood on 401, siis juurdepääsutoken on aegunud (need tokenid kehtivad ainult 10 minutit). Uus juurdepääsutoken taotletakse ja päring tehakse uuesti.

Vastasel juhul saadetakse veateade seeriamonitori ja text jäetakse tühjaks.

Lisa selle meetodi lõppu järgmine kood, et sulgeda HTTP klient ja tagastada tekst:
```
httpClient.end();

return text;
```
main.cpp failis kutsu processAudio funktsioonis välja uus convertSpeechToText meetod ja logi kõne seeriamonitori:
```
String text = speechToText.convertSpeechToText();
Serial.println(text);
```

Koosta see kood, laadi see oma Wio Terminali ja testi seda seeriamonitori kaudu. Kui näed seeriamonitoris Ready, vajuta C nuppu (vasakpoolne nupp, mis on kõige lähemal toitelülitile) ja räägi. 4 sekundit heli salvestatakse ja seejärel muudetakse tekstiks.

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

💁 Selle koodi leiad kaustast code-speech-to-text/wio-terminal.

😀 Sinu kõne tekstiks programm oli edukas!

Lahtiütlus:
See dokument on tõlgitud AI tõlketeenuse Co-op Translator abil. Kuigi püüame tagada täpsust, palume arvestada, et automaatsed tõlked võivad sisaldada vigu või ebatäpsusi. Algne dokument selle algses keeles tuleks pidada autoriteetseks allikaks. Olulise teabe puhul soovitame kasutada professionaalset inimtõlget. Me ei vastuta selle tõlke kasutamisest tulenevate arusaamatuste või valesti tõlgenduste eest.

21 KiB Raw Permalink Blame History