# టైమర్ సెట్ చేయండి - వర్చువల్ IoT హార్డ్వేర్ మరియు రాస్ప్బెరి పి

ఈ పాఠంలో, మీరు మీ సర్వర్లెస్ కో드를 పిలిచి స్పీచ్ ను అర్థం చేసుకోగలుగుతారు, మరియు ఫలితాల ఆధారంగా మీ వర్చువల్ IoT డివైస్ లేదా రాస్ప్బెరి పి లో టైమర్కు సెటప్ చేయగలుగుతారు.

## టైమర్ సెట్ చేయండి

స్పీచ్ టు టెక్స్ట్ కాల్ నుండి వచ్చే టెక్స్ట్‌ను LUIS ద్వారా ప్రాసెస్ చేయడానికి మీ సర్వర్లెస్ కోడ్ కు పంపాలి, ఇది టైమర్ కోసం సెకన్ల సంఖ్యను తిరిగి ఇస్తుంది. ఈ సెకన్ల సంఖ్య టైమర్ సెట్ చేయడానికి ఉపయోగపడుతుంది.

Pythonలో `threading.Timer` క్లాస్ ఉపయోగించి టైమర్ సెట్ చేయవచ్చు. ఈ క్లాస్ పవన సమయం మరియు ఒక ఫంక్షన్ తీసుకుంటుంది, పవన సమయం తరువాత ఆ ఫంక్షన్ అమలులోకి వస్తుంది.

### పనితీరు - టెక్స్ట్ ని సర్వర్లెస్ ఫంక్షన్ కి పంపండి

1. VS Code లో `smart-timer` ప్రాజెక్ట్ తెరవండి, మరియు మీరు వర్చువల్ IoT డివైస్ ఉపయోగిస్తున్నట్లయితే టెర్మినల్ లో వర్చువల్ ఎన్విరాన్మెంట్ లోడ్ అయ్యిందో లేదో నిర్ధారించుకోండి.

1. `process_text` ఫంక్షన్ పైభాగంలో, మీరు సృష్టించిన REST ఎండ్పాయింట్ ను పిలవడానికి `get_timer_time` అనే ఫంక్షన్ ప్రకటించండి:

    ```python
    def get_timer_time(text):
    ```

1. ఈ ఫంక్షన్లో కాల్ చేయాల్సిన URL నిర్వచించేందుకు క్రింది కోడ్ జోడించండి:

    ```python
    url = '<URL>'
    ```

    మీరు గత పాఠంలో మీ కంప్యూటర్ లేదా క్లౌడ్ లో నిర్మించిన REST ఎండ్పాయింట్ యొక్క URL తో `<URL>` ని మార్చండి.

1. కాల్ కు JSON గా పంపే ప్రాపర్టీగా టెక్స్ట్ సెట్ చేయడానికి క్రింది కోడ్ జోడించండి:

    ```python
    body = {
        'text': text
    }
    
    response = requests.post(url, json=body)
    ```

1. దీని కింద, స్పందనలోని `seconds` ను పొందండి, కాల్ విఫలమైనట్లయితే 0 తిరిగి ఇవ్వండి:

    ```python
    if response.status_code != 200:
        return 0
    
    payload = response.json()
    return payload['seconds']
    ```

    విజయవంతమైన HTTP కాల్స్ 200 రేంజ్ లో స్టేటస్ కోడ్ ఇవ్వడం జరుగుతుంది మరియు టెక్స్ట్ సెట్ టైమర్ ఉద్దేశ్యంగా ప్రాసెస్ అయ్యి గుర్తించినప్పుడు మీ సర్వర్లెస్ కోడ్ 200 ఇస్తుంది.

### పనితీరు - బ్యాక్‌గ్రౌండ్ థ్రెడ్ లో టైమర్ సెట్ చేయండి

1. ఫైలుపైభాగంలో Python threading లైబ్రరీని దిగుమతి చేసుకోవడానికి క్రింది ఇంపోర్ట్ స్టేట్‌మెంట్ జోడించండి:

    ```python
    import threading
    ```

1. `process_text` ఫంక్షన్ పైభాగంలో, ప్రతిస్పందన మాట్లాడే ఫంక్షన్ జోడించండి. ఇప్పటివరకు ఇది కేవలం కన్సోల్ పై రాయడం మాత్రమే, కానీ ఈ పాఠం తరువాత ఇది టెక్స్ట్ మాట్లాడుతుంది.

    ```python
    def say(text):
        print(text)
    ```

1. దీని కింద, టైమర్ పూర్తయిందని ప్రకటించడానికై కాల్ చేయబడే ఫంక్షన్ జోడించండి:

    ```python
    def announce_timer(minutes, seconds):
        announcement = 'Times up on your '
        if minutes > 0:
            announcement += f'{minutes} minute '
        if seconds > 0:
            announcement += f'{seconds} second '
        announcement += 'timer.'
        say(announcement)
    ```

    ఈ ఫంక్షన్ టైమర్ కోసం నిమిషాలు మరియు సెకన్ల సంఖ్యను తీసుకుని, టైమర్ పూర్తయినట్టు చెప్పే వాక్యం తయారుచేస్తుంది. ఇది నిమిషాలు మరియు సెకన్ల సంఖ్యలను చెక్ చేసి, అందజేసే ప్రతి టైం యూనిట్‌కు సంఖ్య ఉన్నప్పుడే చేర్చుతుంది. ఉదాహరణకు, నిమిషాలు 0 అయితే సందేశంలో కేవలం సెకన్లు మాత్రమే ఉంటాయి. ఈ వాక్యం తరువాత `say` ఫంక్షన్ కి పంపబడుతుంది.

1. దీని క్రింద ఇచ్చిన `create_timer` ఫంక్షన్ జోడించండి:

    ```python
    def create_timer(total_seconds):
        minutes, seconds = divmod(total_seconds, 60)
        threading.Timer(total_seconds, announce_timer, args=[minutes, seconds]).start()
    ```

    ఈ ఫంక్షన్ పంపబడిన మొత్తం సెకన్ల సంఖ్యను నిమిషాలు మరియు సెకన్లలోకి మార్చుతుంది. తర్వాత మొత్తం సెకన్లతో టైమర్ ఆబ్జెక్ట్ సృష్టించి ప్రారంభిస్తుంది, `announce_timer` ఫంక్షన్ మరియు నిమిషాలు, సెకన్ల జాబితాను కాల్ కి పంపుతుంది. టైమర్ పూర్తయినప్పుడు ఇది `announce_timer` ఫంక్షన్ పిలవబడుతుంది, మరియు జాబితాలోని మొదటి అంశం `minutes` పారా మీటర్ గా, రెండవది `seconds` పారా మీటర్ గా అందుతుంది.

1. `create_timer` ఫంక్షన్ చివరిలో, టైమర్ ప్రారంభమవుతున్నట్లు వినియోగదారుని చెప్పేందుకు కొన్ని కోడ్ జోడించండి:

    ```python
    announcement = ''
    if minutes > 0:
        announcement += f'{minutes} minute '
    if seconds > 0:
        announcement += f'{seconds} second '    
    announcement += 'timer started.'
    say(announcement)
    ```

    దీనిలో కూడా కేవలం విలువ ఉన్న టైం యూనిట్ మాత్రమే చేర్చబడుతుంది. ఈ వాక్యం తరువాత `say` ఫంక్షన్ కి పంపబడుతుంది.

1. `process_text` ఫంక్షన్ చివరకి, టెక్స్ట్ నుండి టైమర్ కోసం సమయాన్ని పొందేందుకు, తర్వాత టైమర్ సృష్టించేందుకు క్రింది వాక్యాలు జోడించండి:

    ```python
    seconds = get_timer_time(text)
    if seconds > 0:
        create_timer(seconds)
    ```

    సెకన్ల సంఖ్య 0 కంటే ఎక్కువ ఉన్నపుడు మాత్రమే టైమర్ సృష్టించబడుతుంది.

1. యాప్ నడిపించండి, మరియు ఫంక్షన్ యాప్ కూడా నడుస్తున్నదని నిర్ధారించుకోండి. కొన్ని టైమర్లు సెట్ చేయండి, అవుట్‌పుట్ లో టైమర్ సెట్ అవడం కనపడుతుంది మరియు టైమర్ పూర్తయ్యినప్పుడు చూపిస్తుంది:

    ```output
    pi@raspberrypi:~/smart-timer $ python3 app.py 
    Set a two minute 27 second timer.
    2 minute 27 second timer started.
    Times up on your 2 minute 27 second timer.
    ```

> 💁 మీరు ఈ కోడ్ ను [code-timer/pi](../../../../../6-consumer/lessons/3-spoken-feedback/code-timer/pi) లేదా [code-timer/virtual-iot-device](../../../../../6-consumer/lessons/3-spoken-feedback/code-timer/virtual-iot-device) ఫోల్డర్ లో కనుగొనవచ్చు.

😀 మీ టైమర్ ప్రోగ్రామ్ విజయవంతమైంది!

---

<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**అస్పష్టత**:
ఈ పత్రం AI అనువాద సేవ అయిన [కో-ఆప్ ట్రాన్స్‌లేటర్](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మా ప్రాముఖ్యత సరైన అనువాదంపై ఉన్నప్పటికీ, ఆటోమేటిక్ అనువాదంలో పొరపాట్లు లేదా లోపాలుండవచ్చును. అసలు పత్రాన్ని దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. కీలక సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం ఉపయోగించడంవల్ల జరిగిన ఏవైనా అపార్థాలు లేదా తప్పుడు అర్థాలు కోసం మేము బాధ్యత వహించము.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->