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.
133 lines
11 KiB
133 lines
11 KiB
# టైమర్ సెట్ చేయండి - వర్చువల్ 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 --> |