# ಟೈಮರ್ ಸೆಟ್ ಮಾಡಿ - ವರ್ಚುವಲ್ ಐಒಟಿ ಹಾರ್ಡ್‌ವೇರ್ ಮತ್ತು ರಾಸ್ಪ್ಬೆರಿ ಪೈ

ಈ ಪಾಠದ ಭಾಗದಲ್ಲಿ, ನೀವು ನಿಮ್ಮ ಸರ್ವರ್‌ಲೆಸ್ ಕೋಡ್ ಅನ್ನು ಕರೆಮಾಡಿ ಭಾಷಣವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೀರಿ ಮತ್ತು نتيಜೆಗಳ ಆಧಾರವಾಗಿ ನಿಮ್ಮ ವರ್ಚುವಲ್ ಐಒಟಿ ಡಿವೈಸ್ ಅಥವಾ ರಾಸ್ಪ್ಬೆರಿ ಪೈನಲ್ಲಿ ಟೈಮರ್ ಅನ್ನು ಸೆಟ್ ಮಾಡುತ್ತೀರಿ.

## ಟೈಮರ್ ಸೆಟ್ ಮಾಡಿ

ಭಾಷಣದಿಂದ ಪಠ್ಯಕ್ಕೆ ಕರೆಮಾಡಿದ ನಂತರ ಬಂದಿರುವ ಪಠ್ಯವನ್ನು ನಿಮ್ಮ ಸರ್ವರ್‌ಲೆಸ್ ಕೋಡ್ ಗೆ ಕಳುಹಿಸುವ ಅಗತ್ಯವಿದೆ, ಅದನ್ನು LUIS ಮೂಲಕ ಪ್ರಕ್ರಿಯೆ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಟೈಮರ್ ಗೆ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲಾಗುತ್ತದೆ. ಈ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆ ಟೈಮರ್ ಸೆಟ್ ಮಾಡಲು ಬಳಸಬಹುದು.

Python `threading.Timer` ವರ್ಗದ ಮೂಲಕ ಟೈಮರ್‌ಗಳನ್ನು ಸೆಟ್ ಮಾಡಬಹುದು. ಈ ವರ್ಗ ಡಿಲೇ ಸಮಯ ಮತ್ತು ಫಂಕ್ಷನ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ಡಿಲೇ ಸಮಯಕ್ಕಿಂತ ನಂತರ, ಆ ಫಂಕ್ಷನ್ ನಿರ್ವಹಣೆ ಆಗುತ್ತದೆ.

### ಕಾರ್ಯ - ಪಠ್ಯವನ್ನು ಸರ್ವರ್‌ಲೆಸ್ ಫಂಕ್ಷನ್ ಗೆ ಕಳುಹಿಸಿ

1. VS Code ನಲ್ಲಿ `smart-timer` ಪ್ರಾಜೆಕ್ಟ್ ಓಪನ್ ಮಾಡಿ, ಮತ್ತು ನೀವು ವರ್ಚುವಲ್ ಐಒಟಿ ಡಿವೈಸ್ ಬಳಸುತ್ತಿದ್ದರೆ ಟರ್ಮಿನಲ್ ನಲ್ಲಿ ವರ್ಚುವಲ್ ಎನ್‌ವೈರನ್ಮೆಂಟ್ ಲೋಡ್ ಆಗಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

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 -->
**ಅಸ್ವೀಕಾರವಾಣಿ**:  
ಈ ದಾಖಲೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಎಂಬ AI ಭಾಷಾಂತರ ಸೇವೆಯನ್ನು ಬಳಸಿಕೊಳಲಾಗಿ ಭಾಷಾಂತರಿಸಲಾಗಿದೆ. ನಿಖರತೆಯನ್ನು ನಾವು ಪ್ರಯತ್ನಿಸಿದರೂ ಸ್ವಯಂಚಾಲಿತ ಭಾಷಾಂತರಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಯುಂಟಾಗಬಹುದೆಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ದಾಖಲೆ ಅದರ ಸ್ಥಳೀಯ ಭಾಷೆಯಲ್ಲಿ ಅಧಿಕೃತ ಮೂಲವಾಗಿರುತ್ತದೆ. ಮಹತ್ವಪೂರ್ಣ ಮಾಹಿತಿಗಾಗಿ ವೃತ್ತಿಪರ ಮಾನವ ಭಾಷಾಂತರ ಪರಿಗಣಿಸುವುದು ಉತ್ತಮ. ಈ ಭಾಷಾಂತರ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ಅರ್ಥ ಗೊಂದಲಗಳಿಗೆ ಅಥವಾ ತಪ್ಪಾಗುವ ವ್ಯಾಖ್ಯಾನಗಳಿಗೆ ನಾವು ಜವಾಬ್ದಾರಿಯಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->