# టైమర్‌ను సెట్ చేయండి - 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 -->