22 KiB

Raw Permalink Blame History

Kalbos pavertimas tekstu - Wio Terminal

Šioje pamokos dalyje rašysite kodą, kuris užfiksuotą garsą pavers tekstu naudodamas kalbos paslaugą.

Siųskite garsą į kalbos paslaugą

Garsą galima siųsti į kalbos paslaugą naudojant REST API. Norint naudotis kalbos paslauga, pirmiausia reikia gauti prieigos žetoną, o tada naudoti tą žetoną REST API pasiekimui. Šie prieigos žetonai galioja tik 10 minučių, todėl jūsų kodas turėtų reguliariai juos atnaujinti, kad jie visada būtų galiojantys.

Užduotis - gauti prieigos žetoną

Atidarykite projektą smart-timer, jei jis dar neatidarytas.

Pridėkite šias bibliotekų priklausomybes į platformio.ini failą, kad galėtumėte naudotis WiFi ir apdoroti JSON:

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

Pridėkite šį kodą į config.h antraštės failą:
```
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";
```
Pakeiskite <SSID> ir <PASSWORD> į atitinkamas jūsų WiFi reikšmes.

Pakeiskite <API_KEY> į jūsų kalbos paslaugos ištekliaus API raktą. Pakeiskite <LOCATION> į vietą, kurią nurodėte kurdami kalbos paslaugos išteklį.

Pakeiskite <LANGUAGE> į kalbos, kuria kalbėsite, lokalės pavadinimą, pavyzdžiui, en-GB anglų kalbai arba zn-HK kantoniečių kalbai. Palaikomų kalbų ir jų lokalės pavadinimų sąrašą galite rasti Microsoft dokumentacijoje apie kalbų ir balsų palaikymą.

Konstantą TOKEN_URL sudaro žetono išdavimo paslaugos URL be vietos. Vėliau tai bus sujungta su vieta, kad būtų gautas pilnas URL.

Kaip ir jungiantis prie Custom Vision, jums reikės naudoti HTTPS ryšį, kad prisijungtumėte prie žetono išdavimo paslaugos. Pridėkite šį kodą į config.h failo pabaigą:

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

Tai tas pats sertifikatas, kurį naudojote jungdamiesi prie Custom Vision.

Pridėkite WiFi antraštės failo ir config antraštės failo įtraukimą į main.cpp failo viršų:
```
#include <rpcWiFi.h>

#include "config.h"
```

Pridėkite kodą, kuris prisijungia prie WiFi, į main.cpp virš setup funkcijos:

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

    Serial.println("Connected!");
}

Iškvieskite šią funkciją iš setup funkcijos po to, kai bus užmegztas serijinis ryšys:
```
connectWiFi();
```
Sukurkite naują antraštės failą src aplanke, pavadintą speech_to_text.h. Šiame antraštės faile pridėkite šį kodą:
```
#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;
```
Tai apima būtinus antraštės failus HTTP ryšiui, konfigūracijai ir mic.h antraštės failą, taip pat apibrėžia klasę SpeechToText, prieš paskelbiant šios klasės egzempliorių, kuris bus naudojamas vėliau.
Pridėkite šiuos 2 laukus į šios klasės private sekciją:
```
WiFiClientSecure _token_client;
String _access_token;
```
_token_client yra WiFi klientas, naudojantis HTTPS ir bus naudojamas prieigos žetonui gauti. Šis žetonas bus saugomas _access_token.

Pridėkite šį metodą į private sekciją:

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

Šis kodas sukuria URL žetono išdavimo API, naudodamas kalbos ištekliaus vietą. Tada jis sukuria HTTPClient, kad atliktų žiniatinklio užklausą, nustatydamas jį naudoti WiFi klientą, sukonfigūruotą su žetono galinių taškų sertifikatu. Jis nustato API raktą kaip antraštę užklausai. Tada jis atlieka POST užklausą, kad gautų sertifikatą, pakartodamas, jei gauna klaidų. Galiausiai grąžinamas prieigos žetonas.

Į public sekciją pridėkite metodą, skirtą gauti prieigos žetoną. Jis bus reikalingas vėlesnėse pamokose tekstui paversti į kalbą.
```
String AccessToken()
{
    return _access_token;
}
```
Į public sekciją pridėkite init metodą, kuris nustato žetono klientą:
```
void init()
{
    _token_client.setCACert(TOKEN_CERTIFICATE);
    _access_token = getAccessToken();
}
```
Tai nustato sertifikatą WiFi klientui, tada gauna prieigos žetoną.
main.cpp faile pridėkite šį naują antraštės failą į įtraukimų direktyvas:
```
#include "speech_to_text.h"
```
Inicializuokite SpeechToText klasę setup funkcijos pabaigoje, po mic.init iškvietimo, bet prieš Ready išvedimą į serijinį monitorių:
```
speechToText.init();
```

Užduotis - skaityti garsą iš flash atminties

Ankstesnėje šios pamokos dalyje garsas buvo įrašytas į flash atmintį. Šis garsas turės būti siunčiamas į Kalbos paslaugų REST API, todėl jį reikia perskaityti iš flash atminties. Jo negalima įkelti į atminties buferį, nes jis būtų per didelis. HTTPClient klasė, kuri atlieka REST užklausas, gali perduoti duomenis naudodama Arduino Stream - klasę, kuri gali įkelti duomenis mažais gabalėliais, siųsdama juos po vieną kaip užklausos dalį. Kiekvieną kartą, kai iškviečiate read ant srauto, jis grąžina kitą duomenų bloką. Arduino srautas gali būti sukurtas, kad galėtų skaityti iš flash atminties. Sukurkite naują failą, pavadintą flash_stream.h, src aplanke, ir pridėkite šį kodą:
```
#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:

};
```
Tai deklaruoja FlashStream klasę, paveldinčią iš Arduino Stream klasės. Tai yra abstrakti klasė - paveldinčios klasės turi įgyvendinti kelis metodus, kol klasė gali būti instancijuota, ir šie metodai yra apibrėžti šioje klasėje.

✅ Daugiau apie Arduino srautus skaitykite Arduino Stream dokumentacijoje
Pridėkite šiuos laukus į private sekciją:
```
size_t _pos;
size_t _flash_address;
const sfud_flash *_flash;

byte _buffer[HTTP_TCP_BUFFER_SIZE];
```
Tai apibrėžia laikiną buferį duomenims, skaitomiems iš flash atminties, saugoti, kartu su laukais, skirtais dabartinei pozicijai buferyje ir dabartiniam adresui flash atmintyje saugoti.
private sekcijoje pridėkite šį metodą:
```
void populateBuffer()
{
    sfud_read(_flash, _flash_address, HTTP_TCP_BUFFER_SIZE, _buffer);
    _flash_address += HTTP_TCP_BUFFER_SIZE;
    _pos = 0;
}
```
Šis kodas skaito iš flash atminties dabartiniu adresu ir saugo duomenis buferyje. Tada jis padidina adresą, kad kitas iškvietimas skaitytų kitą atminties bloką. Buferio dydis nustatytas pagal didžiausią gabalą, kurį HTTPClient siunčia REST API vienu metu.

💁 Flash atminties trynimas turi būti atliekamas naudojant grūdų dydį, tačiau skaitymas to nereikalauja.
public sekcijoje šios klasės pridėkite konstruktorių:
```
FlashStream()
{
    _pos = 0;
    _flash_address = 0;
    _flash = sfud_get_device_table() + 0;

    populateBuffer();
}
```
Šis konstruktorius nustato visus laukus, kad pradėtų skaityti nuo flash atminties bloko pradžios, ir įkelia pirmą duomenų gabalą į buferį.
Įgyvendinkite write metodą. Šis srautas tik skaitys duomenis, todėl šis metodas nieko nedaro ir grąžina 0:
```
virtual size_t write(uint8_t val)
{
    return 0;
}
```
Įgyvendinkite peek metodą. Šis metodas grąžina duomenis dabartinėje pozicijoje, nejudindamas srauto į priekį. Keli peek iškvietimai visada grąžins tuos pačius duomenis, jei iš srauto nebus skaitoma.
```
virtual int peek()
{
    return _buffer[_pos];
}
```
Įgyvendinkite available funkciją. Ši funkcija grąžina, kiek baitų galima skaityti iš srauto, arba -1, jei srautas baigtas. Šiai klasei maksimalus galimas dydis neviršys HTTPClient gabalo dydžio. Kai šis srautas naudojamas HTTP kliente, jis iškviečia šią funkciją, kad pamatytų, kiek duomenų yra prieinama, tada prašo tiek duomenų siųsti REST API. Nenorime, kad kiekvienas gabalas būtų didesnis nei HTTP kliento gabalo dydis, todėl jei yra daugiau duomenų, grąžinamas gabalo dydis. Jei mažiau, grąžinama, kiek yra prieinama. Kai visi duomenys perduoti, grąžinama -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;
}
```
Įgyvendinkite read metodą, kad grąžintų kitą baitą iš buferio, padidindamas poziciją. Jei pozicija viršija buferio dydį, jis užpildo buferį kitu bloku iš flash atminties ir atstato poziciją.
```
virtual int read()
{
    int retVal = _buffer[_pos++];

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

    return retVal;
}
```
speech_to_text.h antraštės faile pridėkite įtraukimo direktyvą šiam naujam antraštės failui:
```
#include "flash_stream.h"
```

Užduotis - paversti kalbą tekstu

Kalba gali būti paversta tekstu siunčiant garsą į Kalbos paslaugą per REST API. Šis REST API turi kitą sertifikatą nei žetono išdavėjas, todėl pridėkite šį kodą į config.h antraštės failą, kad apibrėžtumėte šį sertifikatą:

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

Pridėkite konstantą šiame faile kalbos URL be vietos. Tai bus sujungta su vieta ir kalba vėliau, kad būtų gautas pilnas URL.

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

speech_to_text.h antraštės faile, private sekcijoje SpeechToText klasės, apibrėžkite lauką WiFi klientui, naudojančiam kalbos sertifikatą:
```
WiFiClientSecure _speech_client;
```
init metode nustatykite šio WiFi kliento sertifikatą:
```
_speech_client.setCACert(SPEECH_CERTIFICATE);
```
Pridėkite šį kodą į public sekciją SpeechToText klasės, kad apibrėžtumėte metodą kalbai paversti tekstu:
```
String convertSpeechToText()
{

}
```
Pridėkite šį kodą į šį metodą, kad sukurtumėte HTTP klientą, naudojantį WiFi klientą, sukonfigūruotą su kalbos sertifikatu, ir naudodami kalbos URL, nustatytą su vieta ir kalba:
```
char url[128];
sprintf(url, SPEECH_URL, SPEECH_LOCATION, LANGUAGE);

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

Kai kurios antraštės turi būti nustatytos ryšiui:

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

Tai nustato antraštes autorizacijai naudojant prieigos žetoną, garso formatui naudojant mėginių ėmimo dažnį ir nustato, kad klientas tikisi rezultato JSON formatu.

Po to pridėkite šį kodą, kad atliktumėte REST API užklausą:

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

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

Serial.println("Speech sent!");

Tai sukuria FlashStream ir naudoja jį duomenims perduoti REST API.

Po to pridėkite šį kodą:

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

Šis kodas tikrina atsakymo kodą.

Jei jis yra 200, sėkmės kodas, tada rezultatas gaunamas, dekoduojamas iš JSON, ir DisplayText savybė nustatoma į text kintamąjį. Tai yra savybė, kurioje grąžinamas kalbos tekstinis variantas.

Jei atsakymo kodas yra 401, tada prieigos žetonas pasibaigė (šie žetonai galioja tik 10 minučių). Gaunamas naujas prieigos žetonas ir užklausa atliekama dar kartą.

Kitu atveju klaida siunčiama į serijinį monitorių, o text lieka tuščias.

Pridėkite šį kodą šio metodo pabaigoje, kad uždarytumėte HTTP klientą ir grąžintumėte tekstą:
```
httpClient.end();

return text;
```
main.cpp faile iškvieskite šį naują convertSpeechToText metodą processAudio funkcijoje, tada išveskite kalbą į serijinį monitorių:
```
String text = speechToText.convertSpeechToText();
Serial.println(text);
```

Sukurkite šį kodą, įkelkite jį į savo Wio Terminal ir išbandykite per serijinį monitorių. Kai serijiniame monitore pamatysite Ready, paspauskite C mygtuką (kairėje pusėje, arčiausiai maitinimo jungiklio) ir kalbėkite. 4 sekundės garso bus užfiksuotos, tada paverstos tekstu.

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

💁 Šį kodą galite rasti code-speech-to-text/wio-terminal aplanke.

😀 Jūsų kalbos pavertimo tekstu programa buvo sėkminga!

Atsakomybės apribojimas:
Šis dokumentas buvo išverstas naudojant dirbtinio intelekto vertimo paslaugą Co-op Translator. Nors siekiame tikslumo, atkreipiame dėmesį, kad automatiniai vertimai gali turėti klaidų ar netikslumų. Originalus dokumentas jo gimtąja kalba turėtų būti laikomas autoritetingu šaltiniu. Kritinei informacijai rekomenduojama naudotis profesionalių vertėjų paslaugomis. Mes neprisiimame atsakomybės už nesusipratimus ar klaidingus aiškinimus, kylančius dėl šio vertimo naudojimo.

22 KiB Raw Permalink Blame History