<!--
CO_OP_TRANSLATOR_METADATA:
{
  "original_hash": "64ad4ddb4de81a18b7252e968f10b404",
  "translation_date": "2025-08-27T13:45:43+00:00",
  "source_file": "6-consumer/lessons/3-spoken-feedback/single-board-computer-set-timer.md",
  "language_code": "mr"
}
-->
# टाइमर सेट करा - व्हर्च्युअल IoT हार्डवेअर आणि रास्पबेरी पाय

या धड्याच्या भागामध्ये, तुम्ही तुमचा सर्व्हरलेस कोड कॉल कराल, भाषेचा अर्थ समजून घेण्यासाठी आणि परिणामांवर आधारित तुमच्या व्हर्च्युअल IoT डिव्हाइस किंवा रास्पबेरी पायवर टाइमर सेट कराल.

## टाइमर सेट करा

स्पीच टू टेक्स्ट कॉलमधून परत आलेला मजकूर तुमच्या सर्व्हरलेस कोडला पाठवणे आवश्यक आहे, जो LUIS द्वारे प्रक्रिया केली जाईल आणि टाइमरसाठी सेकंदांची संख्या परत मिळेल. ही सेकंदांची संख्या टाइमर सेट करण्यासाठी वापरली जाऊ शकते.

टाइमर सेट करण्यासाठी Python च्या `threading.Timer` क्लासचा वापर केला जाऊ शकतो. हा क्लास एक विलंब वेळ आणि एक फंक्शन घेतो, आणि विलंब वेळेनंतर ते फंक्शन कार्यान्वित केले जाते.

### कार्य - मजकूर सर्व्हरलेस फंक्शनला पाठवा

1. VS Code मध्ये `smart-timer` प्रोजेक्ट उघडा आणि जर तुम्ही व्हर्च्युअल IoT डिव्हाइस वापरत असाल तर टर्मिनलमध्ये व्हर्च्युअल एन्व्हायर्नमेंट लोड केले असल्याची खात्री करा.

1. `process_text` फंक्शनच्या वर, `get_timer_time` नावाचे एक फंक्शन घोषित करा जे तुम्ही तयार केलेल्या REST एन्डपॉइंटला कॉल करेल:

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

1. या फंक्शनमध्ये खालील कोड जोडा जे कॉल करण्यासाठी URL परिभाषित करेल:

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

    `<URL>` ला तुमच्या REST एन्डपॉइंटच्या 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. फाईलच्या शीर्षस्थानी खालील इम्पोर्ट स्टेटमेंट जोडा जे threading Python लायब्ररी आयात करेल:

    ```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) फोल्डरमध्ये शोधू शकता.

😀 तुमचा टाइमर प्रोग्राम यशस्वी झाला!

---

**अस्वीकृती**:  
हा दस्तऐवज AI भाषांतर सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) वापरून भाषांतरित करण्यात आला आहे. आम्ही अचूकतेसाठी प्रयत्नशील असलो तरी कृपया लक्षात ठेवा की स्वयंचलित भाषांतरांमध्ये त्रुटी किंवा अचूकतेचा अभाव असू शकतो. मूळ भाषेतील दस्तऐवज हा अधिकृत स्रोत मानला जावा. महत्त्वाच्या माहितीसाठी व्यावसायिक मानवी भाषांतराची शिफारस केली जाते. या भाषांतराचा वापर करून निर्माण होणाऱ्या कोणत्याही गैरसमज किंवा चुकीच्या अर्थासाठी आम्ही जबाबदार राहणार नाही.