You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
294 lines
17 KiB
294 lines
17 KiB
# టైమర్ను సెట్ చేయండి - Wio టెర్మినల్
|
|
|
|
ఈ పాఠం భాగంలో, మీరు మీ సర్వర్లెస్ కోడ్ను పిలిచి మాట్లాడు உணரును అర్థం చేసుకోవడానికి, మరియు ఫలితాల ఆధారంగా Wio టెర్మినల్పై టైమర్ని సెట్ చేయడానికి ఉపయోగిస్తారు.
|
|
|
|
## టైమర్ను సెట్ చేయండి
|
|
|
|
మాటల నుంచి టెక్స్ట్కు కాల్ చేసిన తర్వాత వచ్చే టెక్స్ట్ని LUIS ద్వారా ప్రాసెస్ చేయడానికి మీ సర్వర్లెస్ కోడ్కు పంపాలి, ఇందులో టైమర్ కోసం సెకన్ల సంఖ్య తిరిగి వస్తుంది. ఈ సెకన్ల సంఖ్యను ఉపయోగించి టైమర్ సెట్ చేయవచ్చు.
|
|
|
|
మైక్రోకంట్రోలర్లు ఆదునాకి నేటివ్గా విద్ ధారల (multiple threads) మద్దతు కలిగి ఉండగా, Python లేదా ఇతర హెచ్చుతగ్గు ఉన్న భాషలలో కనిపించే ప్రామాణిక టైమర్ క్లాసులు ఉండవు. స్థానంలో, మీరు `loop` ఫంక్షన్లో గడిచిన సమయాన్ని కొలిచి సమయం ముగిసినప్పుడు ఫంక్షన్లను పిలిచే టైమర్ లైబ్రరీలను ఉపయోగించవచ్చు.
|
|
|
|
### పని - టెక్స్ట్ని సర్వర్లెస్ ఫంక్షన్కు పంపండి
|
|
|
|
1. `smart-timer` ప్రాజెక్ట్ను VS కోడ్లో తెరువండి, అది ఇప్పటికే తెరవబడలేదా చూడండి.
|
|
|
|
1. `config.h` హెడర్ ఫైల్ను తెరువు, మరియు మీ ఫంక్షన్ యాప్ కోసం URLని జోడించండి:
|
|
|
|
```cpp
|
|
const char *TEXT_TO_TIMER_FUNCTION_URL = "<URL>";
|
|
```
|
|
|
|
`<URL>` ని మీరు గత పాఠంలోని చివరలో పొందిన ఫంక్షన్ యాప్ యొక్క URLతో మార్చండి, ఇది స్థానిక మెషీన్ IP చిరునామాను చూపుతుంది.
|
|
|
|
1. `src` ఫోల్డర్లో `language_understanding.h` అనే కొత్త ఫైల్ సృష్టించండి. ఈ ఫైల్, గుర్తించిన మాటలు సెకన్లుగా మార్చడానికి LUIS ఉపయోగించి ఫంక్షన్ యాప్కు పంపేందుకు క్లాస్ను నిర్వచించడానికి ఉపయోగపడుతుంది.
|
|
|
|
1. ఈ ఫైల్ టాప్ వద్ద క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
#pragma once
|
|
|
|
#include <Arduino.h>
|
|
#include <ArduinoJson.h>
|
|
#include <HTTPClient.h>
|
|
#include <WiFiClient.h>
|
|
|
|
#include "config.h"
|
|
```
|
|
|
|
ఇది కొన్ని అవసరమైన హెడర్ ఫైళ్లను చేర్చుతుంది.
|
|
|
|
1. `LanguageUnderstanding` అనే క్లాస్ను నిర్వచించండి మరియు ఈ క్లాస్ యొక్క ఇన్స్టెన్స్ను ప్రకటించండి:
|
|
|
|
```cpp
|
|
class LanguageUnderstanding
|
|
{
|
|
public:
|
|
private:
|
|
};
|
|
|
|
LanguageUnderstanding languageUnderstanding;
|
|
```
|
|
|
|
1. మీ ఫంక్షన్ యాప్ని పిలవడానికి WiFi క్లయింట్ను ప్రకటించాలి. క్లాస్ యొక్క `private` విభాగంలో క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
WiFiClient _client;
|
|
```
|
|
|
|
1. `public` విభాగంలో, ఫంక్షన్ యాప్ను పిలవడానికి `GetTimerDuration` అనే విధానాన్ని ప్రకటించండి:
|
|
|
|
```cpp
|
|
int GetTimerDuration(String text)
|
|
{
|
|
}
|
|
```
|
|
|
|
1. `GetTimerDuration` విధానంలో, ఫంక్షన్ యాప్కు పంపాల్సిన JSONని రూపొందించే క్రింది కోడ్ను జోడించండి:
|
|
|
|
```cpp
|
|
DynamicJsonDocument doc(1024);
|
|
doc["text"] = text;
|
|
|
|
String body;
|
|
serializeJson(doc, body);
|
|
```
|
|
|
|
ఇది `GetTimerDuration`కు ఇచ్చిన టెక్స్ట్ని క్రింది JSONగా మార్చుతుంది:
|
|
|
|
```json
|
|
{
|
|
"text" : "<text>"
|
|
}
|
|
```
|
|
|
|
ఇక్కడ `<text>` అనేది ఫంక్షన్కు ఇచ్చిన టెక్స్ట్.
|
|
|
|
1. దీని కింద, ఫంక్షన్ యాప్ కాల్ చేయడానికి క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
HTTPClient httpClient;
|
|
httpClient.begin(_client, TEXT_TO_TIMER_FUNCTION_URL);
|
|
|
|
int httpResponseCode = httpClient.POST(body);
|
|
```
|
|
|
|
ఇది ఫంక్షన్ యాప్కు POST అభ్యర్థనను చేస్తుంది, JSON శరీరాన్ని పంపించి, స్పందన కోడ్ను పొందుతుంది.
|
|
|
|
1. దీని తర్వాత, క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
int seconds = 0;
|
|
if (httpResponseCode == 200)
|
|
{
|
|
String result = httpClient.getString();
|
|
Serial.println(result);
|
|
|
|
DynamicJsonDocument doc(1024);
|
|
deserializeJson(doc, result.c_str());
|
|
|
|
JsonObject obj = doc.as<JsonObject>();
|
|
seconds = obj["seconds"].as<int>();
|
|
}
|
|
else
|
|
{
|
|
Serial.print("Failed to understand text - error ");
|
|
Serial.println(httpResponseCode);
|
|
}
|
|
```
|
|
|
|
ఈ కోడ్ స్పందన కోడ్ను తనిఖీ చేస్తుంది. 200 (సక్సెస్) అయితే, సమయానికి కావలసిన సెకన్ల సంఖ్య స్పందన శరీరం నుంచి పునఃప్రాప్తి అవుతుంది. లేకుంటే సీరియల్ మానిటర్కు దోషం పంపించి, సెకన్లు 0 గా సెట్ చేస్తుంది.
|
|
|
|
1. ఈ విధానం చివరకు క్రింది కోడ్ జోడించి HTTP కనెక్షన్ను మూసి, సెకన్ల సంఖ్యను తిరిగి ఇవ్వండి:
|
|
|
|
```cpp
|
|
httpClient.end();
|
|
|
|
return seconds;
|
|
```
|
|
|
|
1. `main.cpp` ఫైల్లో, ఈ కొత్త హెడర్ను ఇంపోర్ట్ చేయండి:
|
|
|
|
```cpp
|
|
#include "speech_to_text.h"
|
|
```
|
|
|
|
1. `processAudio` ఫంక్షన్ చివర, టైమర్ వ్యవధిని పొందడానికి `GetTimerDuration` పిలవండి:
|
|
|
|
```cpp
|
|
int total_seconds = languageUnderstanding.GetTimerDuration(text);
|
|
```
|
|
|
|
ఇది `SpeechToText` క్లాస్ నుండి టెక్స్ట్ను టైమర్ కోసం సెకన్లు సంఖ్యలో మార్చుతుంది.
|
|
|
|
### పని - టైమర్ సెట్ చేయండి
|
|
|
|
సెకన్ల సంఖ్యను ఉపయోగించి టైమర్ సెట్ చేయవచ్చు.
|
|
|
|
1. టైమర్ సెట్ చేయడానికి లైబ్రరీని జోడించడానికి `platformio.ini` ఫైల్లో క్రింది లైబ్రరీ ఆధారితాన్ని జోడించండి:
|
|
|
|
```ini
|
|
contrem/arduino-timer @ 2.3.0
|
|
```
|
|
|
|
1. ఈ లైబ్రరీ కోసం `main.cpp` ఫైల్లో include డైరెక్టివ్ జోడించండి:
|
|
|
|
```cpp
|
|
#include <arduino-timer.h>
|
|
```
|
|
|
|
1. `processAudio` ఫంక్షన్ కంటే ముందు క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
auto timer = timer_create_default();
|
|
```
|
|
|
|
ఈ కోడ్ `timer` అనే టైమర్ను ప్రకటిస్తుంది.
|
|
|
|
1. దీని కింద క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
void say(String text)
|
|
{
|
|
Serial.print("Saying ");
|
|
Serial.println(text);
|
|
}
|
|
```
|
|
|
|
ఈ `say` ఫంక్షన్ భవిష్యత్తులో మాటగా మారుతుంది, కానీ ఇప్పటివరకు ఇక్కడ ఇచ్చిన టెక్స్ట్ సీరియల్ మానిటర్కి రాయబడుతుంది.
|
|
|
|
1. `say` ఫంక్షన్ కింద క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
bool timerExpired(void *announcement)
|
|
{
|
|
say((char *)announcement);
|
|
return false;
|
|
}
|
|
```
|
|
|
|
ఇది ఒక కాల్బ్యాక్ ఫంక్షన్, టైమర్ ముగిసినప్పుడు పిలవబడుతుంది. ఇది టైమర్ ముగిసినప్పుడు చెప్పాల్సిన సందేశాన్ని అందుకుంటుంది. టైమర్లు పునరావృతమవవచ్చు, దీనిని ఈ కాల్బ్యాక్ తిరిగివస్తు విలువ ద్వారా నియంత్రించవచ్చు - ఇది `false`ని తిరిగి ఇస్తుంది, ఫిర్యాదు జరగకుండా టైమర్ను ఆపేందుకు.
|
|
|
|
1. `processAudio` ఫంక్షన్ చివర క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
if (total_seconds == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int minutes = total_seconds / 60;
|
|
int seconds = total_seconds % 60;
|
|
```
|
|
|
|
ఈ కోడ్ సెకన్ల మొత్తం తనిఖీ చేస్తుంది, 0 కంటే చాలు అయితే ఫంక్షన్ నుండి తిరిగి వెళ్తుంది, కాబట్టి టైమర్లు సెట్ అవ్వవు. తర్వాత మొత్తం సెకన్లను నిమిషాలు మరియు సెకన్లుగా మార్చుతుంది.
|
|
|
|
1. ఈ కోడ్ కింద టైమర్ ప్రారంభించబడినప్పుడు చెప్పే సందేశాన్ని సృష్టించడానికి క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
String begin_message;
|
|
if (minutes > 0)
|
|
{
|
|
begin_message += minutes;
|
|
begin_message += " minute ";
|
|
}
|
|
if (seconds > 0)
|
|
{
|
|
begin_message += seconds;
|
|
begin_message += " second ";
|
|
}
|
|
|
|
begin_message += "timer started.";
|
|
```
|
|
|
|
1. దీనికి కింద, టైమర్ ముగిసినప్పుడు చెప్పే సందేశాన్ని సృష్టించడానికి సమానమైన కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
String end_message("Times up on your ");
|
|
if (minutes > 0)
|
|
{
|
|
end_message += minutes;
|
|
end_message += " minute ";
|
|
}
|
|
if (seconds > 0)
|
|
{
|
|
end_message += seconds;
|
|
end_message += " second ";
|
|
}
|
|
|
|
end_message += "timer.";
|
|
```
|
|
|
|
1. ఈ తర్వాత, టైమర్ ప్రారంభమైన సందేశాన్ని చెప్పండి:
|
|
|
|
```cpp
|
|
say(begin_message);
|
|
```
|
|
|
|
1. ఈ ఫంక్షన్ చివర, టైమర్ను ప్రారంభించండి:
|
|
|
|
```cpp
|
|
timer.in(total_seconds * 1000, timerExpired, (void *)(end_message.c_str()));
|
|
```
|
|
|
|
ఇది టైమర్ను ప్రారంభిస్తుంది. టైమర్ milliseconds లో సెట్ చేయబడుతుంది, అందుకని సెకన్ల మొత్తం 1,000తో గుణించబడుతుంది. `timerExpired` ఫంక్షన్ కాల్బ్యాక్గా ఇవ్వబడుతుంది, `end_message` అతను తెచ్చే ఆర్గ్యుమెంట్గా పంపబడుతుంది. ఈ కాల్బ్యాక్ `void *` ఆర్గ్యుమెంట్స్ మాత్రమే తీసుకోవడంతో స్ట్రింగ్ సరైన రీతిలో మార్చబడుతుంది.
|
|
|
|
1. చివరగా, టైమర్ చలించేందుకు (`tick`) అవసరం, ఇది `loop` ఫంక్షన్లో చేయబడుతుంది. `loop` ఫంక్షన్ చివర క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
timer.tick();
|
|
```
|
|
|
|
1. ఈ కోడ్ను తయారు చేసి, మీ Wio టెర్మినల్కు అప్లోడ్ చేసి, సీరియల్ మానిటర్ ద్వారా పరీక్షించండి. సీరియల్ మానిటర్లో `Ready` కనబడిన వెంటనే, C బటన్ (ఎడమవైపు, పవర్ స్విచ్ దగ్గర ఉన్నది) నొక్కి మాట్లాడండి. 4 సెకన్ల ఆడియో క్యాప్చర్ కావడం, టెక్స్ట్గా మారడం, మీ ఫంక్షన్ యాప్కు పంపడం, ఆ తర్వాత టైమర్ సెట్ అవ్వడం జరిగినట్లు చూసేరు. మీ ఫంక్షన్ యాప్ స్థానికంగా నడుస్తుందో అని నిర్ధారించుకోండి.
|
|
|
|
మీరు టైమర్ ఎప్పుడు మొదలవుతుందో, ఎప్పుడు ముగుస్తుందో చూడగలరు.
|
|
|
|
```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.
|
|
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.
|
|
{"seconds": 147}
|
|
2 minute 27 second timer started.
|
|
Times up on your 2 minute 27 second timer.
|
|
```
|
|
|
|
> 💁 మీరు ఈ కోడ్ని [code-timer/wio-terminal](../../../../../6-consumer/lessons/3-spoken-feedback/code-timer/wio-terminal) ఫోల్డర్లో కనుగొనవచ్చు.
|
|
|
|
😀 మీ టైమర్ ప్రోగ్రామ్ విజయవంతమైంది!
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**అస్పష్టత**:
|
|
ఈ పుస్తకం AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ద్వారా అనువదించబడింది. మనం ఖచ్చితత్వానికి యత్నిస్తూనే ఉన్నప్పటికీ, స్వయంచాలక అనువాదాల్లో తప్పులు లేదా అవరోధాలు ఉండవచ్చు. మూల పుస్తకాన్ని దాని సొంత భాషలోనే అధికారం గల వనరు గా పరిగణించాలి. అత్యంత గంభీర సమాచారం కోసం, ప్రొఫెషనల్ మానవ అనువాదం సూచించబడుతుంది. ఈ అనువాదం వాడు కలిగించే ఏవైనా తప్పించి లేదా తప్పుగా అర్థం చేసుకోటానికి మేము కాపాడుకోము.
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |