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.
299 lines
22 KiB
299 lines
22 KiB
# మీ IoT డివైస్ను క్లౌడ్కు కనెక్ట్ చేయండి - Wio Terminal
|
|
|
|
ఈ పాఠంలోని ఈ భాగంలో, మీరు మీ Wio Terminalను మీ IoT హబ్కు కనెక్ట్ చేసి, టెలిమెట్రీ పంపటానికి మరియు ఆదేశాలను అందుకోవడానికి ఉపయోగిస్తారు.
|
|
|
|
## మీ డివైస్ను IoT హబ్కు కనెక్ట్ చేయండి
|
|
|
|
తరువాతి దశలో మీ డివైస్ను IoT హబ్కు కనెక్ట్ చేయాలి.
|
|
|
|
### పని - IoT హబ్కు కనెక్ట్ చేయండి
|
|
|
|
1. VS కోడ్లో `soil-moisture-sensor` ప్రాజెక్ట్ను తెరవండి
|
|
|
|
1. `platformio.ini` ఫైల్ను తెరవండి. `knolleary/PubSubClient` లైబ్రరీ డిపెండెన్సీని తీసివేయండి. ఇది పబ్లిక్ MQTT బ్రోకర్కు కనెక్ట్ కావడానికి ఉపయోగించబడింది, కానీ IoT హబ్కు కనెక్ట్ కావడానికి అవసరం లేదు.
|
|
|
|
1. క్రింది లైబ్రరీ డిపెండెన్సీలను జోడించండి:
|
|
|
|
```ini
|
|
seeed-studio/Seeed Arduino RTC @ 2.0.0
|
|
arduino-libraries/AzureIoTHub @ 1.6.0
|
|
azure/AzureIoTUtility @ 1.6.1
|
|
azure/AzureIoTProtocol_MQTT @ 1.6.0
|
|
azure/AzureIoTProtocol_HTTP @ 1.6.0
|
|
azure/AzureIoTSocket_WiFi @ 1.0.2
|
|
```
|
|
|
|
`Seeed Arduino RTC` లైబ్రరీ Wio Terminalలో రియల్-టైం క్లాక్తో ఇంటరాక్ట్ కావడానికి కోడ్ అందిస్తుంది, ఇది సమయాన్ని ట్రాక్ చేయడంలో ఉపయోగపడుతుంది. మిగతా లైబ్రరీలు మీ IoT డివైస్ను IoT హబ్కు కనెక్ట్ అవ్వడానికి అనుమతిస్తాయి.
|
|
|
|
1. `platformio.ini` ఫైల్ బాటమ్లో క్రింది కోడ్ జోడించండి:
|
|
|
|
```ini
|
|
build_flags =
|
|
-DDONT_USE_UPLOADTOBLOB
|
|
```
|
|
|
|
ఇది ఆర్డ్యూనో IoT హబ్ కో드를 కంపైల్ చేసే సమయంలో అవసరమైన కంపైలర్ ఫ్లాగ్ను సెటప్ చేస్తుంది.
|
|
|
|
1. `config.h` హెడ్డర్ ఫైల్ను తెరవండి. అన్ని MQTT సెట్టింగులను తీసివేసి, డివైస్ కనక్షన్ స్ట్రింగ్ కోసం క్రింది కాన్స్టెంట్ను జోడించండి:
|
|
|
|
```cpp
|
|
// IoT హబ్ సెట్టింగులు
|
|
const char *CONNECTION_STRING = "<connection string>";
|
|
```
|
|
|
|
క్రమంలో పంపిన `<connection string>` స్థానాన్ని మీ డివైస్ కనెక్షన్ స్ట్రింగ్తో మార్చండి.
|
|
|
|
1. IoT హబ్ కనెక్షన్ సమయాత్మక టోకెన్ ఉపయోగిస్తుంది. దీని అర్థం, IoT డివైస్ ప్రస్తుతం సమయాన్ని తెలుసుకోవాలి. Windows, macOS లేదా Linux వంటి ఆపరేటింగ్ సిస్టమ్స్ లాగా, మైక్రోకంట్రోల్లర్లు ఇంటర్నెట్ ద్వారా సమయాన్ని ఆటోమేటిక్గా సింక్రొనైజ్ చేయవు. కాబట్టి మీరు [NTP](https://wikipedia.org/wiki/Network_Time_Protocol) సర్వర్ నుండి సమయాన్ని పొందడానికి కోడ్ జోడించాలి. సమయం పొందిన తర్వాత, అది Wio Terminalలో రియల్-టైం క్లాక్లో నిల్వ చేయబడుతుంది, ఇది పవర్ కోల్పోకుండా ఉన్నప్పుడు తర్వాత సరిగా సమయాన్ని రిక్వెస్ట్ చేయగలుగుతుంది. క్రింది కోడ్తో `ntp.h` అనే కొత్త ఫైల్ను జోడించండి:
|
|
|
|
```cpp
|
|
#pragma once
|
|
|
|
#include "DateTime.h"
|
|
#include <time.h>
|
|
#include "samd/NTPClientAz.h"
|
|
#include <sys/time.h>
|
|
|
|
static void initTime()
|
|
{
|
|
WiFiUDP _udp;
|
|
time_t epochTime = (time_t)-1;
|
|
NTPClientAz ntpClient;
|
|
|
|
ntpClient.begin();
|
|
|
|
while (true)
|
|
{
|
|
epochTime = ntpClient.getEpochTime("0.pool.ntp.org");
|
|
|
|
if (epochTime == (time_t)-1)
|
|
{
|
|
Serial.println("Fetching NTP epoch time failed! Waiting 2 seconds to retry.");
|
|
delay(2000);
|
|
}
|
|
else
|
|
{
|
|
Serial.print("Fetched NTP epoch time is: ");
|
|
|
|
char buff[32];
|
|
sprintf(buff, "%.f", difftime(epochTime, (time_t)0));
|
|
Serial.println(buff);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ntpClient.end();
|
|
|
|
struct timeval tv;
|
|
tv.tv_sec = epochTime;
|
|
tv.tv_usec = 0;
|
|
|
|
settimeofday(&tv, NULL);
|
|
}
|
|
```
|
|
|
|
ఈ కోడ్ వివరాలు ఈ పాఠం వెనుకగా ఉన్నాయి. ఇది `initTime` అనే ఫంక్షన్ను నిర్వచిస్తుందని, ఇది NTP సర్వర్ నుంచి ప్రస్తుతం సమయాన్ని పొందుతుంది మరియు Wio Terminalలో క్లాక్ను సెట్ చేస్తుంది.
|
|
|
|
1. `main.cpp` ఫైల్ను తెరిచి, MQTT కోడును మొత్తం తొలగించండి, ఇందులో `PubSubClient.h` హెడ్డర్ ఫైల్, `PubSubClient` వేరియబుల్ డిక్లరేషన్, `reconnectMQTTClient` మరియు `createMQTTClient` మెథడ్స్, మరియు వాటికి సంబంధించిన ఇతర కాల్స్ కూడా ఉన్నాయి. ఈ ఫైల్ WiFiకి కనెక్ట్ అయ్యే, మట్టి తేమను పొందే మరియు దానిని JSON డాక్యుమెంట్లో సృష్టించే కోడ్ మాత్రమే ఉండాలి.
|
|
|
|
1. `main.cpp` ఫైల్ టాప్లో క్రింది `#include` డైరెక్టివ్స్ జోడించి, IoT హబ్ లైబ్రరీలు మరియు సమయాన్ని సెటప్ చేసే హెడ్డర్ ఫైళ్లను చేర్చండి:
|
|
|
|
```cpp
|
|
#include <AzureIoTHub.h>
|
|
#include <AzureIoTProtocol_MQTT.h>
|
|
#include <iothubtransportmqtt.h>
|
|
#include "ntp.h"
|
|
```
|
|
|
|
1. `setup` ఫంక్షన్ చివర క్రింది కాల్ను జోడించి, ప్రస్తుతం సమయాన్ని సెట్ చేయండి:
|
|
|
|
```cpp
|
|
initTime();
|
|
```
|
|
|
|
1. ఫైల్ టాప్లో, `#include` డైరెక్టివ్స్ వెంట క్రింది వేరియబుల్ డిక్లరేషన్ను జోడించండి:
|
|
|
|
```cpp
|
|
IOTHUB_DEVICE_CLIENT_LL_HANDLE _device_ll_handle;
|
|
```
|
|
|
|
ఇది `IOTHUB_DEVICE_CLIENT_LL_HANDLE` అనే హ్యాండిల్ డిక్లేర్ చేస్తుంది, ఇది IoT హబ్ కనెక్షన్కు ఉపయోగపడుతుంది.
|
|
|
|
1. దాని కింద క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
static void connectionStatusCallback(IOTHUB_CLIENT_CONNECTION_STATUS result, IOTHUB_CLIENT_CONNECTION_STATUS_REASON reason, void *user_context)
|
|
{
|
|
if (result == IOTHUB_CLIENT_CONNECTION_AUTHENTICATED)
|
|
{
|
|
Serial.println("The device client is connected to iothub");
|
|
}
|
|
else
|
|
{
|
|
Serial.println("The device client has been disconnected");
|
|
}
|
|
}
|
|
```
|
|
|
|
ఇది ఒక కాల్బ్యాక్ ఫంక్షన్ను డిక్లేర్ చేస్తుంది, ఇది IoT హబ్ కనెక్షన్ స్థితి మారినప్పుడు (కనెక్ట్/డిస్కనెక్ట్) పిలువబడుతుంది. ఈ స్థితి సీరియల్ పోర్ట్కు పంపబడుతుంది.
|
|
|
|
1. అదనంగా, IoT హబ్కు కనెక్ట్ అయ్యే ఫంక్షన్ జోడించండి:
|
|
|
|
```cpp
|
|
void connectIoTHub()
|
|
{
|
|
IoTHub_Init();
|
|
|
|
_device_ll_handle = IoTHubDeviceClient_LL_CreateFromConnectionString(CONNECTION_STRING, MQTT_Protocol);
|
|
|
|
if (_device_ll_handle == NULL)
|
|
{
|
|
Serial.println("Failure creating Iothub device. Hint: Check your connection string.");
|
|
return;
|
|
}
|
|
|
|
IoTHubDeviceClient_LL_SetConnectionStatusCallback(_device_ll_handle, connectionStatusCallback, NULL);
|
|
}
|
|
```
|
|
|
|
ఈ కోడ్ IoT హబ్ లైబ్రరీని ప్రారంభించి, `config.h` ఫైల్లో ఉన్న కనెక్షన్ స్ట్రింగ్ ఉపయోగించి కనెక్షన్ సృష్టిస్తుంది. ఈ కనెక్షన్ MQTT ఆధారితంగా ఉంటుంది. కనెక్షన్ విఫలమైతే, ఆ అవస్థ సీరియల్ పోర్ట్కు పంపబడుతుంది - అవుట్పుట్లో ఇది కనిపిస్తే కనెక్షన్ స్ట్రింగ్ని తనిఖీ చేయండి. చివరగా కనెక్షన్ స్టేటస్ కాల్బ్యాక్ సెటప్ చేస్తుంది.
|
|
|
|
1. ఈ ఫంక్షన్ను `setup` ఫంక్షన్ లో `initTime` కాల్ తర్వాత పిలవండి:
|
|
|
|
```cpp
|
|
connectIoTHub();
|
|
```
|
|
|
|
1. MQTT క్లయింట్ లాగా, ఈ కోడ్ సింగిల్ త్రెడ్లో నడుస్తుంది కాబట్టి హబ్ పంపే మరియు హబ్ చేరుకునే సందేశాలను ప్రాసెస్ చేయడానికి సమయం అవసరం. ఈ కోసం `loop` ఫంక్షన్ టాప్లో క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
IoTHubDeviceClient_LL_DoWork(_device_ll_handle);
|
|
```
|
|
|
|
1. ఈ కోడ్ని బిల్డ్ చేసి అప్లోడ్ చేయండి. సీరియల్ మానిటర్లో కనెక్షన్ కనబడుతుంది:
|
|
|
|
```output
|
|
Connecting to WiFi..
|
|
Connected!
|
|
Fetched NTP epoch time is: 1619983687
|
|
Sending telemetry {"soil_moisture":391}
|
|
The device client is connected to iothub
|
|
```
|
|
|
|
అవుట్పుట్లో మీరు NTP సమయం తీసుకున్నారని, ఆ తర్వాత డివైస్ క్లయింట్ కనెక్ట్ అవుతున్నట్లు చూడవచ్చు. కనెక్ట్ కావడానికి కొన్ని సెకన్లు పట్టవచ్చు, కనుక డివైస్ కనెక్ట్ అయివున్నప్పుడు కూడా మట్టి తేమ అవుట్పుట్లో కనిపించవచ్చు.
|
|
|
|
> 💁 మీరు UNIX సమయాన్ని మరింత చదవదగిన రూపంలోకి మార్చడానికి [unixtimestamp.com](https://www.unixtimestamp.com) వంటి వెబ్సైట్ను ఉపయోగించవచ్చు
|
|
|
|
## టెలిమెట్రీ పంపండి
|
|
|
|
మీ డివైస్ కనెక్ట్ అయిన తర్వాత, మీరు MQTT బ్రోకర్కు బదులు IoT హబ్కు టెలిమెట్రీ పంపవచ్చు.
|
|
|
|
### పని - టెలిమెట్రీ పంపు
|
|
|
|
1. `setup` ఫంక్షన్ కంటే ముందు క్రింది ఫంక్షన్ జోడించండి:
|
|
|
|
```cpp
|
|
void sendTelemetry(const char *telemetry)
|
|
{
|
|
IOTHUB_MESSAGE_HANDLE message_handle = IoTHubMessage_CreateFromString(telemetry);
|
|
IoTHubDeviceClient_LL_SendEventAsync(_device_ll_handle, message_handle, NULL, NULL);
|
|
IoTHubMessage_Destroy(message_handle);
|
|
}
|
|
```
|
|
|
|
ఈ కోడ్ స్ట్రింగ్ రూపంలో వచ్చిన డేటాను IoT హబ్ సందేశంగా సృష్టించి, హబ్కు పంపడమే, తరువాత సందేశ ఆబ్జెక్టును క్లియర్ చేస్తుంది.
|
|
|
|
1. ఈ కోడ్ను `loop` ఫంక్షన్లో, టెలిమెట్రీ సీరియల్ పోర్టుకు పంపిన తర్వాతి లైనులో పిలవండి:
|
|
|
|
```cpp
|
|
sendTelemetry(telemetry.c_str());
|
|
```
|
|
|
|
## ఆదేశాలను హ్యాండిల్ చేయండి
|
|
|
|
మీ డివైస్ సర్వర్ కోడ్ నుంచి రీలే నిర్వహణకు సంబంధించిన ఆదేశాన్ని హ్యాండిల్ చేయాలి. ఇది డైరెక్ట్ మెథడ్ రిక్వెస్ట్ రూపంలో పంపబడుతుంది.
|
|
|
|
## పని - డైరెక్ట్ మెథడ్ రిక్వెస్ట్ని హ్యాండిల్ చేయండి
|
|
|
|
1. `connectIoTHub` ఫంక్షన్ ముందు క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
int directMethodCallback(const char *method_name, const unsigned char *payload, size_t size, unsigned char **response, size_t *response_size, void *userContextCallback)
|
|
{
|
|
Serial.printf("Direct method received %s\r\n", method_name);
|
|
|
|
if (strcmp(method_name, "relay_on") == 0)
|
|
{
|
|
digitalWrite(PIN_WIRE_SCL, HIGH);
|
|
}
|
|
else if (strcmp(method_name, "relay_off") == 0)
|
|
{
|
|
digitalWrite(PIN_WIRE_SCL, LOW);
|
|
}
|
|
}
|
|
```
|
|
|
|
ఈ కోడ్ IoT హబ్ లైబ్రరీ డైరెక్ట్ మెథడ్ రిక్వెస్ట్ అందుకున్నప్పుడు పిలవగల కాల్బ్యాక్ మెథడ్ను నిర్వచిస్తుంది. పిలవబడిన మెథడ్ పేరు `method_name` ప్యారామీటర్లో వస్తుంది. ఈ ఫంక్షన్ మెథడ్ పేరును సీరియల్ పోర్టుకు ప్రింట్ చేసి, ఆ మెథడ్ పేరు ఆధారంగా రీలేని ఆన్ లేదా ఆఫ్ చేస్తుంది.
|
|
|
|
> 💁 ఇది ఒకే డైరెక్ట్ మెథడ్ రిక్వెస్ట్లో కూడా అమలు చేయవచ్చు, అనుకున్న రీలే స్థితిని మెథడ్ రిక్వెస్ట్తో పాటు అందించే పేలొడ్ ద్వారా పంపించి, `payload` ప్యారామీటర్ ద్వారా అందుబాటులో చేయవచ్చు.
|
|
|
|
1. `directMethodCallback` ఫంక్షన్ ముగింపులో క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
char resultBuff[16];
|
|
sprintf(resultBuff, "{\"Result\":\"\"}");
|
|
*response_size = strlen(resultBuff);
|
|
*response = (unsigned char *)malloc(*response_size);
|
|
memcpy(*response, resultBuff, *response_size);
|
|
|
|
return IOTHUB_CLIENT_OK;
|
|
```
|
|
|
|
డైరెక్ట్ మెథడ్ రిక్వెస్ట్కి స్పందన అవసరం, ఇది రెండు భాగాలుగా ఉంటుంది - పాఠ్య స్పందన మరియు రీటర్న్ కోడ్. ఈ కోడ్ క్రింది JSON డాక్యుమెంట్ ఫార్మాట్లో ఫలితాన్ని సృష్టిస్తుంది:
|
|
|
|
```JSON
|
|
{
|
|
"Result": ""
|
|
}
|
|
```
|
|
|
|
దీనిని `response` ప్యారామీటర్లో కాపీ చేసి, స్పందన పరిమాణాన్ని `response_size` ప్యారామీటర్లో సెట్చేస్తుంది. ఆపై ఈ కోడ్ `IOTHUB_CLIENT_OK` తిరిగి ఇస్తుంది, తద్వారా మెథడ్ సరిగ్గా నిర్వహించబడిందని సూచిస్తుంది.
|
|
|
|
1. ఈ కాల్బ్యాక్ను కింది కోడ్ను `connectIoTHub` ఫంక్షన్ ముగింపులో జోడించి కनेक్ట్ చేయండి:
|
|
|
|
```cpp
|
|
IoTHubClient_LL_SetDeviceMethodCallback(_device_ll_handle, directMethodCallback, NULL);
|
|
```
|
|
|
|
1. `loop` ఫంక్షన్, IoT హబ్ పంపే ఈవెంట్స్ని ప్రాసెస్ చేయటానికి `IoTHubDeviceClient_LL_DoWork` ఫంక్షన్ను పిలుస్తుంది. ఇది ప్రతి 10 సెకన్లకు మాత్రమే పిలవబడుతుంది కారణం `delay` కారణంగా, అంటే డైరెక్ట్ మెథడ్స్ కూడా ప్రతి 10 సెకన్లకు ఒకసారి ప్రాసెస్ అవుతాయి. దీన్ని మరింత సమర్థవంతంగా మార్చడానికి, 10 సెకన్ల డిలేను చిన్న చిన్న డిలే లుగా చేయవచ్చు, ప్రతి సారి `IoTHubDeviceClient_LL_DoWork` పిలవబడుతుంది. దీన్ని చేయడానికి, `loop` ఫంక్షన్ ముందు క్రింది కోడ్ జోడించండి:
|
|
|
|
```cpp
|
|
void work_delay(int delay_time)
|
|
{
|
|
int current = 0;
|
|
do
|
|
{
|
|
IoTHubDeviceClient_LL_DoWork(_device_ll_handle);
|
|
delay(100);
|
|
current += 100;
|
|
} while (current < delay_time);
|
|
}
|
|
```
|
|
|
|
ఈ కోడ్ ఆవృతంగా `IoTHubDeviceClient_LL_DoWork` పిలుస్తూ, ప్రతి సారి 100ms డిలే చేస్తుంది. ఇది `delay_time` ప్యారామీటర్లో ఇచ్చిన సమయం వరకు ఈ ప్రక్రియను చేస్తుంది. దీని అర్థం, డివైస్ డైరెక్ట్ మెథడ్ రిక్వెస్ట్లను అత్యధికంగా 100ms లోపు ప్రాసెస్ చేయడానికి వేచి ఉంటుంది.
|
|
|
|
1. `loop` ఫంక్షన్లో, `IoTHubDeviceClient_LL_DoWork` కాల్ను తీసివేసి, `delay(10000)` ని ఈ క్రింది కొత్త ఫంక్షన్ కాల్తో మార్చండి:
|
|
|
|
```cpp
|
|
work_delay(10000);
|
|
```
|
|
|
|
> 💁 మీరు ఈ కోడ్ను [code/wio-terminal](../../../../../2-farm/lessons/4-migrate-your-plant-to-the-cloud/code/wio-terminal) ఫోల్డర్లో చూడవచ్చు.
|
|
|
|
😀 మీ మట్టి తేమ సెన్సార్ ప్రోగ్రామ్ మీ IoT హబ్కు కనెక్ట్ అయింది!
|
|
|
|
---
|
|
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
|
|
**వెళ్లిచూపు**:
|
|
ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నిస్తూనే ఉన్నాం గానీ, ఆటోమేటిక్ అనువాదాల్లో పొరపాట్లు లేదా తప్పులున్నట్లుండవచ్చు. అసలు భాషలో ఉన్న పత్రం అధికారిక మూలంగా పరిగణించాలి. అత్యంత అవసరమైన సమాచారానికి ప్రొఫెషనల్ మానవ అనువాదం చేయించుకోవడం మేలైంది. ఈ అనువాదం వాడుక వల్ల కలిగే ఏవైనా అపార్థాలు లేదా తప్పుదారుల కోసం మేము బాధ్యత వహించము.
|
|
<!-- CO-OP TRANSLATOR DISCLAIMER END --> |