पिछली पोस्ट में, हमने दिखाया था कि एमक्यूटीटी ब्रोकर का उपयोग करके IoT उपकरणों से संदेश कैसे भेजें और प्राप्त करें। इस पोस्ट में हम उस विचार को वास्तविक दुनिया के उदाहरण तक विस्तारित करेंगे।

मान लीजिए आपके पास एक IoT उपकरण है जो ग्रीनहाउस में तापमान और आर्द्रता को मापता है (रास्पबेरी पाई या Arduino का उपयोग करके इसे बनाना कठिन नहीं है)।

हम किसी अन्य कंप्यूटर या, शायद, केंद्रीय लॉगिंग सेवा से दूर से ग्रीनहाउस स्थितियों की निगरानी करना चाहते हैं। पिछली पोस्ट में, हमने संदेश भेजने के लिए कोड का गो कार्यान्वयन दिखाया था इसलिए हम उस उदाहरण का विस्तार करेंगे।

केवल "तापमान x है, आर्द्रता y है" कहकर एक स्ट्रिंग भेजने के बजाय, आइए संदेश और डिवाइस के लिए एक संरचना परिभाषित करें। विचार करें कि आपके पास नमी या वर्षा की निगरानी के लिए एक उपकरण है (या भविष्य में जोड़ना चाहते हैं) और आप उसे भी कनेक्ट करना चाहते हैं।

कई उपकरणों और प्रकारों की संभावना को खुला रखने के लिए, हमें इसे संभालने के लिए एक डेटा मॉडल की आवश्यकता है।

type Message struct {
    Time   time.Time `json:"time"`
    Device Device    `json:"device"`
}

type Device interface {
    ID() string
    Name() string
}

type TempRHDevice struct {
    Id         string  `json:"id"`
    DeviceName string  `json:"name,omitempty"`
    Temp       float32 `json:"temp,omitempty"`
    Rh         float32 `json:"rh,omitempty"`
}

func (t TempRHDevice) ID() string {
    return t.Id
}

func (t TempRHDevice) Name() string {
    return t.DeviceName
}

संदेश संरचना वह है जो एमक्यूटीटी ब्रोकर को भेजी जाएगी। हमने अपने IoT उपकरणों की सामान्य विशेषताओं को संभालने और विशिष्ट उपकरणों के विवरण को सारगर्भित करने के लिए एक इंटरफ़ेस बनाया।

TempRHDevice हमारा उपकरण है जो तापमान और आर्द्रता मापता है। यह डिवाइस इंटरफ़ेस को कार्यान्वित करता है, इसलिए इसका उपयोग संदेश में किया जा सकता है।

इसके बाद, हमें ब्रोकर को संदेश भेजना होगा। हम इस उदाहरण में इसकी सरलता के लिए JSON प्रारूप का उपयोग करेंगे। ध्यान दें कि हजारों या अधिक उपकरणों वाले बड़े पैमाने के सिस्टम में, हम अधिक कॉम्पैक्ट प्रारूप का उपयोग करना चाह सकते हैं।

message := generateRandomMessage()
payload, err := json.Marshal(message)
if err != nil {
    panic(err)
}
token := client.Publish(topic, 0, false, payload)

गो JSON में मार्शलिंग को बहुत आसान बनाता है। एक बार मार्शल हो जाने पर, json संदेश ब्रोकर को भेज दिया जाता है।

एक बार डेटा हमारे पास आ जाए तो हम उसके साथ और क्या करना चाहेंगे: इसे डेटाबेस में संग्रहीत करें, इसे डैशबोर्ड पर प्रदर्शित करें, अलार्म स्थितियों के लिए मानों की जांच करें। इसे प्रयोग करने योग्य बनाने के लिए हमें json को परिवर्तित करने की आवश्यकता होगी।

प्राप्त पक्ष पर, हमें बस json को एक संरचना में अनमर्शल करना होगा। हम भेजने वाले पक्ष पर उपयोग की गई संरचना के समान संरचना का उपयोग करेंगे; लेकिन हमें संदेश में डिवाइस इंटरफ़ेस के बजाय एक ठोस प्रकार में अनमर्शल करने का एक तरीका चाहिए। हम कोड को थोड़ा साफ-सुथरा बनाने के लिए संदेश पर एक कस्टम अनमर्शल विधि जोड़ेंगे

type rawMessage struct {
    Time   time.Time `json:"time"`
    Device TempRHDevice    `json:"device"`
}
func (m *Message) UnmarshalJSON(data []byte) error {
    var raw rawMessage
    if err := json.Unmarshal(data, &raw); err != nil {
        return err
    }
    m.Time = raw.Time
    m.Device = &raw.Device
    return nil
}

...

func processMsg(ctx context.Context, ....

...

    case msg, ok := 



यहां यह बताना उचित होगा कि अधिक डिवाइस प्रकार जुड़ने पर यह विधि जटिल हो जाती है। उदाहरण के लिए, UnmarshalJSON विधि से कैसे पता चलेगा कि संदेश में कौन सा डिवाइस प्रकार है। हम प्रकार का पता लगाने के लिए UnmarshalJSON में कुछ चतुर तर्क कर सकते हैं। 

एक अन्य विकल्प के लिए, याद रखें कि एमक्यूटीटी का उपयोग कई विषयों पर प्रकाशित करने के लिए किया जा सकता है और विषयों के लिए उपयोगकर्ता द्वारा पदानुक्रमित नामकरण परंपरा का उपयोग करना आम बात है। इसलिए ग्रीनहाउस उदाहरण में एकाधिक डिवाइस प्रकारों के मामले में, अनुशंसित तरीका यह है कि विभिन्न डिवाइस प्रकारों को अलग-अलग विषयों पर प्रकाशित किया जाए। जब हम नए डिवाइस प्रकार जोड़ेंगे तो आगे बढ़ते हुए हम इसे इसी तरह से संभालेंगे। 

ग्रीनहाउस उदाहरण में, विषय नामों को इस प्रकार संरचित किया जा सकता है:



/greenhouse/temprh/deviceid
/greenhouse/moisture/deviceid




एमक्यूटीटी में, हम वाइल्डकार्ड विषय का उपयोग करके विषयों की सदस्यता ले सकते हैं, जैसे:



if token := client.Subscribe("/greenhouse/#", 0, nil); token.Wait() && token.Error() != nil {
        fmt.Println(token.Error())
        os.Exit(1)
    }




जो ग्रीनहाउस नेमस्पेस में सभी उपकरणों से मेल खाएगा। तो हमें आने वाले संदेश के विषय को देखने के लिए इसे अनमर्शल करने का तरीका जानने के लिए सिर्फ प्रोसेसएमएसजी() में तर्क जोड़ने की आवश्यकता होगी।

अब जब हमारे पास प्रयोग करने योग्य रूप में एक डिवाइस संदेश है, तो इसके साथ क्या किया जाना चाहिए। इस श्रृंखला की अगली पोस्ट में, हम PostGres में संदेश को जारी रखने के लिए अपना दृष्टिकोण प्रदर्शित करेंगे।

हमेशा की तरह प्रेषक के लिए पूरा स्रोत कोड यहां पाया जा सकता है और ग्राहक कोड यहां पाया जा सकता है।

मुझे टिप्पणियों में अपने विचार बताएं।

धन्यवाद!