IoT-க்கு பைத்தான்: MQTT செயல்படுத்துதலுக்கான ஒரு முழுமையான வழிகாட்டி

இணைக்கப்பட்ட உலகம்: IoT நெறிமுறைகள் ஏன் முக்கியமானவை

நாம் முன்னோடியில்லாத இணைப்புள்ள ஒரு காலகட்டத்தில் வாழ்கிறோம். இன்டர்நெட் ஆஃப் திங்ஸ் (IoT) என்பது இனி ஒரு எதிர்காலக் கருத்து அல்ல; அது ஒரு உலகளாவிய யதார்த்தம், நமது சூழலைக் கண்காணிக்கும், நமது வீடுகளைத் தானியக்கமாக்கும், நமது தொழில்களை மேம்படுத்தும், மற்றும் நமது நகரங்களை நெறிப்படுத்தும் பில்லியன் கணக்கான ஸ்மார்ட் சாதனங்களின் வலையமைப்பை அமைதியாகப் பின்னுகிறது. சியோலில் உள்ள ஒரு வீட்டில் உள்ள ஸ்மார்ட் தெர்மோஸ்டாட் முதல் கென்யாவின் கிராமப்புறத்தில் உள்ள ஒரு விவசாய சென்சார் வரை, இந்த சாதனங்கள் ஒரு பெரிய அளவிலான தரவை உருவாக்குகின்றன. ஆனால் அவை அனைத்தும் ஒன்றுக்கொன்று மற்றும் கிளவுடுடன் எப்படிப் பேசுகின்றன, குறிப்பாக அவை பெரும்பாலும் சிறியதாகவும், குறைந்த சக்தியுடனும், நம்பகமற்ற நெட்வொர்க்குகளிலும் செயல்படும் போது? இதற்கான பதில் பிரத்யேக தகவல் தொடர்பு நெறிமுறைகளில் உள்ளது.

நாம் அன்றாடம் பயன்படுத்தும் இணையத்தின் பெரும்பகுதியை HTTP நெறிமுறை இயக்கும் அதே வேளையில், IoT-யின் கட்டுப்பாடான உலகிற்கு அது பெரும்பாலும் மிகவும் கனமானதாகவும், அதிக சக்தி தேவைப்படுவதாகவும் உள்ளது. இந்த இடத்தில்தான் இயந்திரத்திலிருந்து இயந்திரம் (M2M) தகவல்தொடர்புக்காக பிரத்யேகமாக வடிவமைக்கப்பட்ட நெறிமுறைகள் பிரகாசிக்கின்றன. அவற்றுள், ஒன்று ஒரு ஆதிக்க சக்தியாக உருவெடுத்துள்ளது: MQTT.

இந்த விரிவான வழிகாட்டி, IoT துறையில் மிகவும் பல்துறை மற்றும் பிரபலமான நிரலாக்க மொழிகளில் ஒன்றான பைத்தானைப் பயன்படுத்தி MQTT-யின் ஆற்றலைப் பயன்படுத்த விரும்பும் டெவலப்பர்கள், பொறியாளர்கள் மற்றும் பொழுதுபோக்காளர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. நாம் MQTT-யின் அடிப்படைக் கருத்துக்களிலிருந்து தொடங்கி, பாதுகாப்பான, வலுவான மற்றும் அளவிடக்கூடிய IoT பயன்பாடுகளை உருவாக்குவது வரை பயணிப்போம்.

MQTT என்றால் என்ன? கட்டுப்பாடுகளுக்காக உருவாக்கப்பட்ட ஒரு நெறிமுறை

MQTT என்பது Message Queuing Telemetry Transport என்பதன் சுருக்கமாகும். இது 1999 ஆம் ஆண்டில் IBM-ன் டாக்டர் ஆண்டி ஸ்டான்ஃபோர்ட்-கிளார்க் மற்றும் ஆர்காமின் (இப்போது சிரஸ் லிங்க்) ஆர்லன் நிப்பர் ஆகியோரால் நம்பகமற்ற செயற்கைக்கோள் நெட்வொர்க்குகள் மூலம் எண்ணெய் குழாய்களைக் கண்காணிக்க கண்டுபிடிக்கப்பட்டது. அதன் தோற்றக் கதை அதன் நோக்கத்தை மிகச்சரியாக வெளிப்படுத்துகிறது: குறிப்பிடத்தக்க கட்டுப்பாடுகளின் கீழ் செயல்படும் சாதனங்களுக்கான ஒரு இலகுவான, நம்பகமான மற்றும் திறமையான செய்திப் பரிமாற்ற நெறிமுறையாக இருப்பது.

வெளியிடு/சந்தாதாரர் (Pub/Sub) மாதிரி விளக்கம்

MQTT-யின் இதயத்தில் நேர்த்தியான வெளியிடு/சந்தாதாரர் கட்டமைப்பு முறை உள்ளது. இது பல டெவலப்பர்களுக்குப் பழக்கமான HTTP-யின் கோரிக்கை/பதில் மாதிரியிலிருந்து ஒரு அடிப்படை விலகலாகும். ஒரு கிளையன்ட் நேரடியாக ஒரு சேவையகத்திடமிருந்து தகவலைக் கோருவதற்குப் பதிலாக, இங்கு தகவல்தொடர்பு பிரிக்கப்பட்டுள்ளது.

ஒரு உலகளாவிய செய்தி நிறுவனத்தை கற்பனை செய்து பாருங்கள். பத்திரிகையாளர்கள் (வெளியீட்டாளர்கள்) தங்கள் செய்திகளை ஒவ்வொரு வாசகருக்கும் நேரடியாக அனுப்புவதில்லை. அதற்குப் பதிலாக, அவர்கள் தங்கள் செய்திகளை நிறுவனத்தின் மைய மையத்திற்கு (தரகர்) அனுப்பி, அவற்றை "உலக அரசியல்" அல்லது "தொழில்நுட்பம்" போன்ற குறிப்பிட்ட தலைப்புகளின் கீழ் வகைப்படுத்துகிறார்கள். வாசகர்கள் (சந்தாதாரர்கள்) புதுப்பிப்புகளுக்காக பத்திரிகையாளர்களிடம் கேட்க வேண்டியதில்லை; அவர்கள் வெறுமனே தங்களுக்கு ஆர்வமுள்ள தலைப்புகளை நிறுவனத்திடம் கூறுகிறார்கள். நிறுவனம் பின்னர் அந்த தலைப்புகளில் எந்த புதிய செய்திகள் வந்தாலும் அவற்றை ஆர்வமுள்ள வாசகர்களுக்கு தானாகவே அனுப்புகிறது. பத்திரிகையாளர்களும் வாசகர்களும் ஒருவருக்கொருவர் இருப்பு, இடம் அல்லது நிலை பற்றி ஒருபோதும் தெரிந்து கொள்ள வேண்டியதில்லை.

MQTT-யில், இந்த மாதிரி தரவை அனுப்பும் சாதனத்தை (வெளியீட்டாளர்) அதைப் பெறும் சாதனம் அல்லது பயன்பாட்டிலிருந்து (சந்தாதாரர்) பிரிக்கிறது. இது IoT-க்கு நம்பமுடியாத அளவிற்கு சக்தி வாய்ந்தது, ஏனெனில்:

• இடப் பிரிப்பு: வெளியீட்டாளரும் சந்தாதாரரும் ஒருவருக்கொருவர் ஐபி முகவரி அல்லது இருப்பிடத்தை அறிந்து கொள்ள வேண்டியதில்லை.
• நேரப் பிரிப்பு: அவர்கள் ஒரே நேரத்தில் இயங்க வேண்டியதில்லை. ஒரு சென்சார் ஒரு அளவீட்டை வெளியிடலாம், மேலும் ஒரு பயன்பாடு சில மணிநேரங்களுக்குப் பிறகு அதைப் பெறலாம், அமைப்பு அவ்வாறு வடிவமைக்கப்பட்டிருந்தால்.
• ஒத்திசைவுப் பிரிப்பு: ஒரு செய்திப் பரிமாற்றத்தை முடிக்க மற்றொன்றுக்காக இருபுறமும் செயல்பாடுகளை நிறுத்த வேண்டியதில்லை.

MQTT கட்டமைப்பின் முக்கிய கூறுகள்

MQTT கட்டமைப்பு சில முக்கிய கூறுகளின் மீது கட்டமைக்கப்பட்டுள்ளது:

• தரகர் (Broker): மைய மையம் அல்லது சேவையகம். இது MQTT உலகின் தபால் அலுவலகம். வெளியீட்டாளர்களிடமிருந்து அனைத்து செய்திகளையும் பெறுவதற்கும், அவற்றை தலைப்பு வாரியாக வடிகட்டுவதற்கும், அவற்றை பொருத்தமான சந்தாதாரர்களுக்கு அனுப்புவதற்கும் தரகர் பொறுப்பாகும். பிரபலமான தரகர்களில் மாஸ்கிட்டோ (Mosquitto) மற்றும் வெர்ன்எம்யூ (VerneMQ) போன்ற திறந்த மூல விருப்பங்களும், AWS IoT Core, Azure IoT Hub, மற்றும் Google Cloud IoT Core போன்ற நிர்வகிக்கப்பட்ட கிளவுட் சேவைகளும் அடங்கும்.
• கிளையன்ட் (Client): தரகருடன் இணையும் எந்தவொரு சாதனம் அல்லது பயன்பாடு. ஒரு கிளையன்ட் ஒரு வெளியீட்டாளராகவோ, ஒரு சந்தாதாரராகவோ அல்லது இரண்டுமாகவோ இருக்கலாம். ஒரு IoT சென்சார் ஒரு கிளையன்ட், மற்றும் சென்சார் தரவைச் செயல்படுத்தும் ஒரு சேவையக பயன்பாடும் ஒரு கிளையன்ட் ஆகும்.
• தலைப்பு (Topic): செய்திகளுக்கான முகவரி அல்லது லேபிளாக செயல்படும் ஒரு UTF-8 சரம். தரகர் செய்திகளை வழிநடத்த தலைப்புகளைப் பயன்படுத்துகிறார். கோப்பு முறைமைப் பாதை போலவே, தலைப்புகள் முன்னோக்கி சாய்வுகளைப் பிரிப்பான்களாகப் பயன்படுத்தி படிநிலை கொண்டவை. எடுத்துக்காட்டாக, லண்டனில் உள்ள ஒரு கட்டிடத்தில் உள்ள ஒரு வரவேற்பறையில் உள்ள வெப்பநிலை சென்சாருக்கான ஒரு நல்ல தலைப்பு: UK/London/Building-A/Floor-1/LivingRoom/Temperature.
• பேலோடு (Payload): இது செய்தியின் உண்மையான தரவு உள்ளடக்கம். MQTT தரவு-சார்பற்றது, அதாவது பேலோடு எதுவாகவும் இருக்கலாம்: ஒரு எளிய சரம், ஒரு முழு எண், JSON, XML, அல்லது குறியாக்கம் செய்யப்பட்ட பைனரி தரவு கூட. JSON அதன் நெகிழ்வுத்தன்மை மற்றும் படிக்க எளிதாக இருப்பதால் மிகவும் பொதுவான தேர்வாகும்.

IoT தகவல்தொடர்பில் MQTT ஏன் ஆதிக்கம் செலுத்துகிறது

MQTT-யின் வடிவமைப்பு கோட்பாடுகள் IoT-யின் சவால்களுக்கு இது விதிவிலக்காகப் பொருத்தமானதாக ஆக்குகின்றன:

• இலகுவானது: MQTT செய்திகள் மிகச் சிறிய தலைப்பைக் கொண்டுள்ளன (குறைந்தது 2 பைட்டுகள்), இது நெட்வொர்க் அலைவரிசை பயன்பாட்டைக் குறைக்கிறது. விலை உயர்ந்த செல்லுலார் திட்டங்கள் அல்லது LoRaWAN போன்ற குறைந்த அலைவரிசை நெட்வொர்க்குகளில் உள்ள சாதனங்களுக்கு இது மிகவும் முக்கியமானது.
• திறமையானது: நெறிமுறையின் குறைந்த மேல்நிலை நேரடியாக குறைந்த மின் நுகர்வுக்கு வழிவகுக்கிறது, இது பேட்டரியில் இயங்கும் சாதனங்களை மாதங்கள் அல்லது வருடங்கள் கூட செயல்பட அனுமதிக்கிறது.
• நம்பகமானது: இது நிலையற்ற, அதிக தாமதமுள்ள நெட்வொர்க்குகளில் கூட செய்தி விநியோகத்தை உறுதி செய்வதற்கான அம்சங்களைக் கொண்டுள்ளது. இது சேவையின் தர நிலைகள் மூலம் நிர்வகிக்கப்படுகிறது.
• அளவிடக்கூடியது: ஒரு ஒற்றை தரகர் ஒரே நேரத்தில் ஆயிரக்கணக்கான அல்லது மில்லியன் கணக்கான கிளையன்ட்களிடமிருந்து இணைப்புகளைக் கையாள முடியும், இது பெரிய அளவிலான வரிசைப்படுத்தல்களுக்கு ஏற்றதாக அமைகிறது.
• இருவழி: MQTT சாதனத்திலிருந்து கிளவுடுக்கு (தொலை அளவியல்) மற்றும் கிளவுடிலிருந்து சாதனத்திற்கு (கட்டளைகள்) தகவல்தொடர்பை அனுமதிக்கிறது, இது சாதனங்களை தொலைவிலிருந்து கட்டுப்படுத்துவதற்கான ஒரு முக்கிய தேவையாகும்.

சேவையின் தரம் (QoS) பற்றி புரிந்துகொள்ளுதல்

MQTT மூன்று நிலைகளிலான சேவையின் தரத்தை (QoS) வழங்குகிறது, இது டெவலப்பர்கள் தங்கள் குறிப்பிட்ட பயன்பாட்டு வழக்கிற்கு நம்பகத்தன்மைக்கும் மேல்நிலைக்கும் இடையிலான சரியான சமநிலையைத் தேர்வுசெய்ய அனுமதிக்கிறது.

• QoS 0 (அதிகபட்சம் ஒரு முறை): இது ஒரு "சுட்டுவிட்டு மறந்துவிடு" நிலை. செய்தி ஒரு முறை அனுப்பப்படும், தரகரிடமிருந்தோ அல்லது இறுதி சந்தாதாரரிடமிருந்தோ ரசீதுக்கான உறுதிப்படுத்தல் எதுவும் இருக்காது. இது வேகமான முறை ஆனால் விநியோகத்திற்கு எந்த உத்தரவாதமும் அளிக்காது. பயன்பாட்டு வழக்கு: ஒரு அறை வெப்பநிலை அளவீடு ஒவ்வொரு 10 வினாடிகளுக்கும் அனுப்பப்படுவது போன்ற முக்கியமற்ற, அதிக அதிர்வெண் சென்சார் தரவு. ஒரு அளவீட்டை இழப்பது ஒரு பிரச்சனையல்ல.
• QoS 1 (குறைந்தது ஒரு முறை): இந்த நிலை செய்தி குறைந்தது ஒரு முறையாவது விநியோகிக்கப்படும் என்று உத்தரவாதம் அளிக்கிறது. அனுப்புநர் பெறுநரிடமிருந்து ஒரு ஒப்புதல் (ஒரு PUBACK பாக்கெட்) பெறும் வரை செய்தியைச் சேமித்து வைப்பார். ஒப்புதல் பெறப்படாவிட்டால், செய்தி மீண்டும் அனுப்பப்படும். ஒப்புதல் தொலைந்துவிட்டால் இது சில நேரங்களில் நகல் செய்திகளுக்கு வழிவகுக்கும். பயன்பாட்டு வழக்கு: ஒரு ஸ்மார்ட் விளக்கை இயக்குவதற்கான கட்டளை. கட்டளை பெறப்பட்டது என்பதை நீங்கள் உறுதிப்படுத்த வேண்டும், மேலும் அதை இரண்டு முறை பெறுவது தீங்கு விளைவிக்காது.
• QoS 2 (சரியாக ஒரு முறை): இது மிகவும் நம்பகமானது ஆனால் மெதுவான நிலையும் கூட. செய்தி சரியாக ஒரு முறை, நகல்கள் இல்லாமல் விநியோகிக்கப்படுவதை உறுதிசெய்ய இது நான்கு-பகுதி கைக்குலுக்கலைப் பயன்படுத்துகிறது. பயன்பாட்டு வழக்கு: நிதிப் பரிவர்த்தனை, ஒரு குறிப்பிட்ட அளவு மருந்தை வழங்குவதற்கான கட்டளை, அல்லது ஒரு தொழிற்சாலையில் ஒரு ரோபோ கையை கட்டுப்படுத்துவது போன்ற நகல்கள் பேரழிவை ஏற்படுத்தக்கூடிய முக்கியமான செயல்பாடுகள்.

உங்கள் பைத்தான் MQTT சூழலை அமைத்தல்

இப்போது, நடைமுறைக்கு வருவோம். பைத்தான் மூலம் MQTT பயன்பாடுகளை உருவாக்கத் தொடங்க, உங்களுக்கு இரண்டு விஷயங்கள் தேவை: MQTT கிளையன்டுக்கான ஒரு பைத்தான் நூலகம் மற்றும் தொடர்புகொள்வதற்கான ஒரு MQTT தரகர்.

ஒரு பைத்தான் MQTT நூலகத்தைத் தேர்ந்தெடுத்தல்: Paho-MQTT

பைத்தானுக்கான மிகவும் பரவலாகப் பயன்படுத்தப்படும் மற்றும் முதிர்ச்சியடைந்த MQTT நூலகம் எக்லிப்ஸ் அறக்கட்டளையின் Paho-MQTT ஆகும். இது ஒரு வலுவான, அம்சம் நிறைந்த நூலகமாகும், இது ஒரு தரகருடன் இணைவதற்கும், தலைப்புகளில் வெளியிட அல்லது சந்தா செலுத்த ஒரு கிளையன்ட் வகுப்பை வழங்குகிறது. பைத்தானின் தொகுப்பு மேலாளரான pip-ஐப் பயன்படுத்தி இதை நிறுவுவது நேரடியானது.

உங்கள் டெர்மினல் அல்லது கட்டளை வரியில் திறந்து இயக்கவும்:

pip install paho-mqtt

இந்த ஒற்றைக் கட்டளை பைத்தானில் MQTT கிளையன்ட்களை எழுதத் தொடங்கத் தேவையான அனைத்தையும் நிறுவுகிறது.

ஒரு MQTT தரகரை அமைத்தல்

உங்களிடம் ஒரு தரகருக்காக பல விருப்பங்கள் உள்ளன, உங்கள் உள்ளூர் கணினியில் மேம்பாட்டிற்காக ஒன்றை இயக்குவது முதல் உற்பத்திக்காக ஒரு சக்திவாய்ந்த கிளவுட் சேவையைப் பயன்படுத்துவது வரை.

• உள்ளூர் தரகர் (மேம்பாடு மற்றும் கற்றலுக்கு): ஒரு உள்ளூர் தரகருக்கான மிகவும் பிரபலமான தேர்வு மாஸ்கிட்டோ (Mosquitto), மற்றொரு எக்லிப்ஸ் திட்டம். இது இலகுவானது, திறந்த மூலமானது, மற்றும் நிறுவ எளிதானது.
  • டெபியன் அடிப்படையிலான லினக்ஸில் (உபுண்டு, ராஸ்பெர்ரி பை OS போன்றவை): sudo apt-get update && sudo apt-get install mosquitto mosquitto-clients
  • மேக்ஓஎஸ்-இல் (ஹோம்பிரூவைப் பயன்படுத்தி): brew install mosquitto
  • விண்டோஸில்: மாஸ்கிட்டோ வலைத்தளத்திலிருந்து நேட்டிவ் நிறுவியை பதிவிறக்கவும்.
  நிறுவப்பட்டதும், தரகர் பொதுவாக ஒரு சேவையாக தானாகவே தொடங்கிவிடும். உங்கள் கிளையன்ட்களை உங்கள் உள்ளூர் ஐபி முகவரிக்கு (127.0.0.1 அல்லது localhost) சுட்டிக்காட்டுவதன் மூலம் நீங்கள் அதைப் பயன்படுத்தலாம்.
• பொது/கிளவுட் தரகர் (விரைவான சோதனைக்கு): எதையும் நிறுவmadan ஆரம்ப சோதனைகளுக்கு, நீங்கள் ஒரு இலவச, பொது தரகரைப் பயன்படுத்தலாம். இரண்டு பிரபலமானவை test.mosquitto.org மற்றும் broker.hivemq.com. முக்கியம்: இவை பொதுவானவை மற்றும் குறியாக்கம் செய்யப்படாதவை. எந்தவொரு முக்கியமான அல்லது தனிப்பட்ட தரவையும் அவற்றுக்கு அனுப்ப வேண்டாம். அவை கற்றல் மற்றும் சோதனை நோக்கங்களுக்காக மட்டுமே.

செய்முறைப் பயிற்சி: பைத்தான் மூலம் வெளியிடுதல் மற்றும் சந்தா செலுத்துதல்

நமது முதல் பைத்தான் MQTT பயன்பாட்டை எழுதுவோம். நாம் இரண்டு தனித்தனி ஸ்கிரிப்ட்களை உருவாக்குவோம்: செய்திகளை அனுப்பும் ஒரு வெளியீட்டாளர் மற்றும் அவற்றை பெறும் ஒரு சந்தாதாரர். இந்த எடுத்துக்காட்டிற்கு, நீங்கள் ஒரு உள்ளூர் மாஸ்கிட்டோ தரகரை இயக்குகிறீர்கள் என்று வைத்துக்கொள்வோம்.

ஒரு எளிய MQTT வெளியீட்டாளரை உருவாக்குதல் (publisher.py)

இந்த ஸ்கிரிப்ட் தரகருடன் இணைத்து, ஒவ்வொரு இரண்டு வினாடிகளுக்கும் `python/mqtt/test` என்ற தலைப்பிற்கு "Hello, MQTT!" என்ற செய்தியை வெளியிடும்.

`publisher.py` என்ற பெயரில் ஒரு கோப்பை உருவாக்கி, பின்வரும் குறியீட்டைச் சேர்க்கவும்:

import paho.mqtt.client as mqtt

import time

# --- கட்டமைப்பு ---

BROKER_ADDRESS = "localhost" # பொது தரகருக்கு 'test.mosquitto.org' ஐப் பயன்படுத்தவும்

PORT = 1883

TOPIC = "python/mqtt/test"

# --- இணைப்புக்கான கால்பேக் ---

def on_connect(client, userdata, flags, rc):

if rc == 0:

print("MQTT தரகருடன் இணைக்கப்பட்டது!")

else:

print(f"இணைப்பதில் தோல்வி, ரிட்டர்ன் கோட் {rc}")

# --- முக்கிய ஸ்கிரிப்ட் ---

# 1. ஒரு கிளையன்ட் நிகழ்வை உருவாக்கவும்

client = mqtt.Client("PublisherClient")

# 2. on_connect கால்பேக்கை ஒதுக்கவும்

client.on_connect = on_connect

# 3. தரகருடன் இணைக்கவும்

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. நெட்வொர்க் சுழற்சிக்கான பின்னணி திரெட்டைத் தொடங்கவும்

client.loop_start()

try:

count = 0

while True:

count += 1

message = f"வணக்கம், MQTT! செய்தி #{count}"

# 5. ஒரு செய்தியை வெளியிடவும்

result = client.publish(TOPIC, message)

# வெளியீடு வெற்றிகரமாக உள்ளதா என சரிபார்க்கவும்

status = result[0]

if status == 0:

print(f"`{message}` ஐ `{TOPIC}` என்ற தலைப்பிற்கு அனுப்பப்பட்டது")

else:

print(f"{TOPIC} என்ற தலைப்பிற்கு செய்தியை அனுப்ப முடியவில்லை")

time.sleep(2)

except KeyboardInterrupt:

print("வெளியீடு நிறுத்தப்பட்டது.")

finally:

# 6. நெட்வொர்க் சுழற்சியை நிறுத்தி இணைப்பைத் துண்டிக்கவும்

client.loop_stop()

client.disconnect()

print("தரகரிலிருந்து துண்டிக்கப்பட்டது.")

ஒரு எளிய MQTT சந்தாதாரரை உருவாக்குதல் (subscriber.py)

இந்த ஸ்கிரிப்ட் அதே தரகருடன் இணைத்து, `python/mqtt/test` தலைப்பிற்கு சந்தா செலுத்தி, அது பெறும் எந்த செய்தியையும் அச்சிடும்.

`subscriber.py` என்ற மற்றொரு கோப்பை உருவாக்கவும்:

import paho.mqtt.client as mqtt

# --- கட்டமைப்பு ---

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "python/mqtt/test"

# --- கால்பேக் செயல்பாடுகள் ---

def on_connect(client, userdata, flags, rc):

if rc == 0:

print("MQTT தரகருடன் இணைக்கப்பட்டது!")

# வெற்றிகரமாக இணைந்ததும் தலைப்பிற்கு சந்தா செலுத்தவும்

client.subscribe(TOPIC)

else:

print(f"இணைப்பதில் தோல்வி, ரிட்டர்ன் கோட் {rc}")

def on_message(client, userdata, msg):

# செய்தி பேலோடை பைட்டுகளிலிருந்து சரமாக டிகோட் செய்யவும்

payload = msg.payload.decode()

print(f"பெறப்பட்ட செய்தி: `{payload}` தலைப்பில் `{msg.topic}`")

# --- முக்கிய ஸ்கிரிப்ட் ---

# 1. ஒரு கிளையன்ட் நிகழ்வை உருவாக்கவும்

client = mqtt.Client("SubscriberClient")

# 2. கால்பேக்குகளை ஒதுக்கவும்

client.on_connect = on_connect

client.on_message = on_message

# 3. தரகருடன் இணைக்கவும்

client.connect(BROKER_ADDRESS, PORT, 60)

# 4. நெட்வொர்க் சுழற்சியைத் தொடங்கவும் (தடுக்கும் அழைப்பு)

# இந்த செயல்பாடு மீண்டும் இணைத்தல் மற்றும் செய்திகளைத் தானாகச் செயலாக்குவதைக் கையாளுகிறது.

print("சந்தாதாரர் கேட்டுக்கொண்டிருக்கிறார்...")

client.loop_forever()

உதாரணத்தை இயக்குதல்

1. இரண்டு தனித்தனி டெர்மினல் சாளரங்களைத் திறக்கவும்.
2. முதல் டெர்மினலில், சந்தாதாரர் ஸ்கிரிப்டை இயக்கவும்: python subscriber.py
3. "சந்தாதாரர் கேட்டுக்கொண்டிருக்கிறார்..." என்ற செய்தியைக் காண்பீர்கள். அது இப்போது செய்திகளுக்காகக் காத்திருக்கிறது.
4. இரண்டாவது டெர்மினலில், வெளியீட்டாளர் ஸ்கிரிப்டை இயக்கவும்: python publisher.py
5. வெளியீட்டாளர் ஒவ்வொரு இரண்டு விநாடிகளுக்கும் செய்திகளை அனுப்புவதை நீங்கள் காண்பீர்கள். அதே நேரத்தில், இந்த செய்திகள் சந்தாதாரரின் டெர்மினல் சாளரத்தில் தோன்றும்.

வாழ்த்துக்கள்! நீங்கள் இப்போது பைத்தானைப் பயன்படுத்தி ஒரு முழுமையான, செயல்படும் MQTT தகவல்தொடர்பு அமைப்பை உருவாக்கியுள்ளீர்கள்.

அடிப்படைகளைத் தாண்டி: மேம்பட்ட Paho-MQTT அம்சங்கள்

நிஜ-உலக IoT அமைப்புகளுக்கு நமது எளிய உதாரணத்தை விட அதிக வலுவான தன்மை தேவை. உற்பத்திக்குத் தயாரான பயன்பாடுகளை உருவாக்குவதற்கு அவசியமான சில மேம்பட்ட MQTT அம்சங்களை ஆராய்வோம்.

கடைசி விருப்பம் மற்றும் சாசனம் (LWT)

ஒரு பாதுகாப்பு கேமரா அல்லது இதய மானிட்டர் போன்ற ஒரு முக்கியமான சாதனம் மின் செயலிழப்பு அல்லது நெட்வொர்க் இழப்பு காரணமாக எதிர்பாராத விதமாக துண்டிக்கப்பட்டால் என்ன நடக்கும்? LWT அம்சம் MQTT-யின் தீர்வு. ஒரு கிளையன்ட் இணைக்கும்போது, அது தரகருடன் ஒரு "கடைசி விருப்ப" செய்தியை பதிவு செய்யலாம். கிளையன்ட் தவறான முறையில் துண்டிக்கப்பட்டால் (ஒரு DISCONNECT பாக்கெட்டை அனுப்பாமல்), தரகர் தானாகவே இந்த கடைசி விருப்பச் செய்தியை அதன் சார்பாக ஒரு குறிப்பிட்ட தலைப்பில் வெளியிடுவார்.

சாதன நிலை கண்காணிப்புக்கு இது விலைமதிப்பற்றது. ஒரு சாதனம் இணைக்கும்போது `devices/device-123/status` என்ற தலைப்பில் `"online"` என்ற பேலோடுடன் ஒரு செய்தியை வெளியிடலாம், மேலும் அதே தலைப்பில் `"offline"` என்ற பேலோடுடன் ஒரு LWT செய்தியை பதிவு செய்யலாம். இந்த தலைப்பிற்கு சந்தா செலுத்தியுள்ள எந்த கண்காணிப்பு சேவையும் உடனடியாக சாதனத்தின் நிலையை அறிந்து கொள்ளும்.

Paho-MQTT-யில் LWT-ஐ செயல்படுத்த, நீங்கள் இணைக்கும் முன் அதை அமைக்க வேண்டும்:

client.will_set('devices/device-123/status', payload='offline', qos=1, retain=True)

client.connect(BROKER_ADDRESS, PORT, 60)

தக்கவைக்கப்பட்ட செய்திகள்

பொதுவாக, ஒரு சந்தாதாரர் ஒரு தலைப்புடன் இணைந்தால், அது சந்தா செலுத்திய பிறகு வெளியிடப்படும் செய்திகளை மட்டுமே பெறும். ஆனால் உங்களுக்கு மிக சமீபத்திய மதிப்பு உடனடியாக தேவைப்பட்டால் என்ன செய்வது? இதற்காகத்தான் தக்கவைக்கப்பட்ட செய்திகள் உள்ளன. `retain` கொடி `True` என அமைக்கப்பட்ட ஒரு செய்தி வெளியிடப்படும்போது, தரகர் அந்த செய்தியை அந்த குறிப்பிட்ட தலைப்பிற்காக சேமிக்கிறார். ஒரு புதிய கிளையன்ட் அந்த தலைப்பிற்கு சந்தா செலுத்தும் போதெல்லாம், அது உடனடியாக கடைசி தக்கவைக்கப்பட்ட செய்தியைப் பெறும்.

நிலைத் தகவலுக்கு இது மிகவும் பொருத்தமானது. ஒரு சாதனம் அதன் நிலையை (எ.கா., `{"state": "ON"}`) `retain=True` உடன் வெளியிடலாம். தொடங்கும் மற்றும் சந்தா செலுத்தும் எந்தவொரு பயன்பாடும் அடுத்த புதுப்பிப்புக்காகக் காத்திருக்காமல் உடனடியாக சாதனத்தின் தற்போதைய நிலையை அறிந்து கொள்ளும்.

Paho-MQTT-யில், நீங்கள் உங்கள் வெளியீட்டு அழைப்பில் `retain` கொடியைச் சேர்த்தால் போதும்:

client.publish(TOPIC, payload, qos=1, retain=True)

நிலையான அமர்வுகள் மற்றும் தூய அமர்வுகள்

கிளையன்டின் இணைப்பு கோரிக்கையில் உள்ள `clean_session` கொடி, தரகர் கிளையன்டின் அமர்வை எவ்வாறு கையாள்கிறார் என்பதைக் கட்டுப்படுத்துகிறது.

• தூய அமர்வு (clean_session=True, இயல்புநிலை): கிளையன்ட் துண்டிக்கப்படும்போது, தரகர் அதன் சந்தாக்கள் மற்றும் வரிசையில் உள்ள QoS 1 அல்லது 2 செய்திகள் உட்பட அதைப் பற்றிய அனைத்து தகவல்களையும் நிராகரிக்கிறார். அது மீண்டும் இணைக்கும்போது, அது ஒரு புத்தம் புதிய கிளையன்ட் போல இருக்கும்.
• நிலையான அமர்வு (clean_session=False): ஒரு தனித்துவமான கிளையன்ட் ஐடியுடன் ஒரு கிளையன்ட் இந்த வழியில் இணைக்கும்போது, தரகர் அது துண்டிக்கப்பட்ட பிறகும் அதன் அமர்வைப் பராமரிக்கிறார். இதில் அதன் சந்தாக்கள் மற்றும் அது ஆஃப்லைனில் இருந்தபோது வெளியிடப்பட்ட எந்த QoS 1 அல்லது 2 செய்திகளும் அடங்கும். கிளையன்ட் மீண்டும் இணைக்கும்போது, தரகர் தவறவிட்ட அனைத்து செய்திகளையும் அனுப்புகிறார். இது முக்கியமான கட்டளைகளை இழக்க முடியாத நம்பகமற்ற நெட்வொர்க்குகளில் உள்ள சாதனங்களுக்கு மிகவும் முக்கியமானது.

ஒரு நிலையான அமர்வை நிறுவ, நீங்கள் ஒரு நிலையான, தனித்துவமான கிளையன்ட் ஐடியை வழங்க வேண்டும் மற்றும் கிளையன்ட் நிகழ்வை உருவாக்கும்போது `clean_session=False` என அமைக்க வேண்டும்:

client = mqtt.Client(client_id="my-persistent-device-001", clean_session=False)

பாதுகாப்பு ஒரு விருப்பமல்ல: பைத்தான் மூலம் MQTT ஐப் பாதுகாத்தல்

எந்தவொரு நிஜ-உலக பயன்பாட்டிலும், பாதுகாப்பு மிக முக்கியமானது. ஒரு பாதுகாப்பற்ற MQTT தரகர், உங்கள் தரவை ஒட்டுக்கேட்க, உங்கள் சாதனங்களுக்கு தவறான கட்டளைகளை அனுப்ப, அல்லது சேவை மறுப்பு தாக்குதல்களைத் தொடங்க தீங்கிழைக்கும் நடிகர்களுக்கு ஒரு திறந்த அழைப்பாகும். MQTT-ஐப் பாதுகாப்பது மூன்று முக்கிய தூண்களை உள்ளடக்கியது: அங்கீகாரம், குறியாக்கம் மற்றும் அங்கீகாரம்.

அங்கீகாரம்: நீங்கள் யார்?

அங்கீகாரம் தரகருடன் இணையும் கிளையன்டின் அடையாளத்தைச் சரிபார்க்கிறது. எளிமையான முறை ஒரு பயனர்பெயர் மற்றும் கடவுச்சொல்லைப் பயன்படுத்துவதாகும். உங்கள் மாஸ்கிட்டோ தரகரை சான்றுகள் தேவைப்படுமாறு கட்டமைத்து, பின்னர் அவற்றை உங்கள் பைத்தான் கிளையன்டில் வழங்கலாம்.

உங்கள் பைத்தான் கிளையன்டில், `username_pw_set()` முறையைப் பயன்படுத்தவும்:

client.username_pw_set(username="myuser", password="mypassword")

client.connect(BROKER_ADDRESS, PORT, 60)

குறியாக்கம்: TLS/SSL மூலம் பயணத்தில் உள்ள தரவைப் பாதுகாத்தல்

பயனர்பெயர் மற்றும் கடவுச்சொல் நெட்வொர்க்கில் வெற்று உரையாக அனுப்பப்பட்டால் அவை பயனற்றவை. குறியாக்கம் கிளையன்டிற்கும் தரகருக்கும் இடையிலான அனைத்து தகவல்தொடர்புகளும் குழப்பப்பட்டு, நெட்வொர்க்கில் உளவு பார்ப்பவர்களுக்கு படிக்க முடியாததாக இருப்பதை உறுதி செய்கிறது. இது போக்குவரத்து அடுக்கு பாதுகாப்பு (TLS) மூலம் அடையப்படுகிறது, இது வலைத்தளங்களைப் பாதுகாக்கும் அதே தொழில்நுட்பம் (HTTPS).

MQTT உடன் TLS-ஐப் பயன்படுத்த (பெரும்பாலும் MQTTS என்று அழைக்கப்படுகிறது), நீங்கள் அதை ஆதரிக்க உங்கள் தரகரை உள்ளமைக்க வேண்டும் (பொதுவாக போர்ட் 8883 இல்) மற்றும் தேவையான சான்றிதழ்களை உங்கள் கிளையன்டிற்கு வழங்க வேண்டும். இது பொதுவாக தரகரின் அடையாளத்தைச் சரிபார்க்க ஒரு சான்றிதழ் ஆணைய (CA) சான்றிதழை உள்ளடக்கியது.

Paho-MQTT-யில், நீங்கள் `tls_set()` முறையைப் பயன்படுத்துகிறீர்கள்:

client.tls_set(ca_certs="path/to/ca.crt")

client.connect(BROKER_ADDRESS, 8883, 60)

அங்கீகாரம்: நீங்கள் என்ன செய்ய அனுமதிக்கப்படுகிறீர்கள்?

ஒரு கிளையன்ட் அங்கீகரிக்கப்பட்டவுடன், அங்கீகாரம் அது என்ன செய்ய அனுமதிக்கப்படுகிறது என்பதை தீர்மானிக்கிறது. எடுத்துக்காட்டாக, ஒரு வெப்பநிலை சென்சார் அதன் சொந்த தலைப்பிற்கு (எ.கா., `sensors/temp-A/data`) மட்டுமே வெளியிட அனுமதிக்கப்பட வேண்டும், ஆனால் ஒரு தொழிற்சாலையின் இயந்திரங்களைக் கட்டுப்படுத்தப் பயன்படுத்தப்படும் ஒரு தலைப்பிற்கு (எ.கா., `factory/floor-1/robot-arm/command`) அல்ல. இது பொதுவாக அணுகல் கட்டுப்பாட்டு பட்டியல்களைப் (ACLs) பயன்படுத்தி தரகரில் கையாளப்படுகிறது. குறிப்பிட்ட தலைப்பு வடிவங்களுக்கு எந்த பயனர்கள் `படிக்க` (சந்தா செலுத்த) அல்லது `எழுத` (வெளியிட) முடியும் என்பதை வரையறுக்கும் விதிகளுடன் நீங்கள் தரகரை உள்ளமைக்கிறீர்கள்.

அனைத்தையும் ஒன்றிணைத்தல்: ஒரு எளிய ஸ்மார்ட் சுற்றுச்சூழல் கண்காணிப்புத் திட்டம்

இந்தக் கருத்துக்களை வலுப்படுத்த சற்று யதார்த்தமான ஒரு திட்டத்தை உருவாக்குவோம். சுற்றுச்சூழல் தரவை JSON பொருளாக வெளியிடும் ஒரு சென்சார் சாதனத்தையும், இந்தத் தரவிற்கு சந்தா செலுத்தி அதைக் காண்பிக்கும் ஒரு கண்காணிப்பு பயன்பாட்டையும் உருவகப்படுத்துவோம்.

திட்ட மேலோட்டம்

• சென்சார் (வெளியீட்டாளர்): வெப்பநிலை மற்றும் ஈரப்பதத்தைப் படிக்கும் ஒரு சென்சாரை உருவகப்படுத்தும் ஒரு பைத்தான் ஸ்கிரிப்ட். இது இந்தத் தரவை ஒரு JSON பேலோடில் தொகுத்து, ஒவ்வொரு 5 விநாடிக்கும் smart_env/device01/telemetry என்ற தலைப்பில் வெளியிடும்.
• மானிட்டர் (சந்தாதாரர்): smart_env/device01/telemetry-க்கு சந்தா செலுத்தும் ஒரு பைத்தான் ஸ்கிரிப்ட், JSON தரவைப் பெற்று, அதை அலசி, ஒரு பயனர் நட்பு நிலை புதுப்பிப்பை அச்சிடும்.

சென்சார் குறியீடு (sensor_publisher.py)

import paho.mqtt.client as mqtt

import time

import json

import random

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "smart_env/device01/telemetry"

client = mqtt.Client("SensorDevice01")

client.connect(BROKER_ADDRESS, PORT, 60)

client.loop_start()

print("சென்சார் வெளியீட்டாளர் தொடங்கப்பட்டது...")

try:

while True:

# சென்சார் அளவீடுகளை உருவகப்படுத்துங்கள்

temperature = round(random.uniform(20.0, 30.0), 2)

humidity = round(random.uniform(40.0, 60.0), 2)

# ஒரு JSON பேலோடை உருவாக்கவும்

payload = {

"timestamp": time.time(),

"temperature": temperature,

"humidity": humidity

}

payload_str = json.dumps(payload)

# QoS 1 உடன் செய்தியை வெளியிடவும்

result = client.publish(TOPIC, payload_str, qos=1)

result.wait_for_publish() # வெளியீடு உறுதிசெய்யப்படும் வரை தடுக்கவும்

print(f"வெளியிடப்பட்டது: {payload_str}")

time.sleep(5)

except KeyboardInterrupt:

print("சென்சார் வெளியீட்டாளரை நிறுத்துகிறது...")

finally:

client.loop_stop()

client.disconnect()

கண்காணிப்பு டாஷ்போர்டு குறியீடு (monitor_subscriber.py)

import paho.mqtt.client as mqtt

import json

import datetime

BROKER_ADDRESS = "localhost"

PORT = 1883

TOPIC = "smart_env/device01/telemetry"

def on_connect(client, userdata, flags, rc):

print(f"முடிவு குறியீடு {rc} உடன் இணைக்கப்பட்டது")

client.subscribe(TOPIC)

def on_message(client, userdata, msg):

print("--- புதிய செய்தி பெறப்பட்டது ---")

try:

# பேலோடு சரத்தை டிகோட் செய்து அதை JSON ஆக அலசவும்

payload = json.loads(msg.payload.decode())

timestamp = datetime.datetime.fromtimestamp(payload.get('timestamp'))

temperature = payload.get('temperature')

humidity = payload.get('humidity')

print(f"சாதனம்: {msg.topic}")

print(f"நேரம்: {timestamp.strftime('%Y-%m-%d %H:%M:%S')}")

print(f"வெப்பநிலை: {temperature}°C")

print(f"ஈரப்பதம்: {humidity}%")

except json.JSONDecodeError:

print("JSON பேலோடை டிகோட் செய்வதில் பிழை.")

except Exception as e:

print(f"ஒரு பிழை ஏற்பட்டது: {e}")

client = mqtt.Client("MonitoringDashboard")

client.on_connect = on_connect

client.on_message = on_message

client.connect(BROKER_ADDRESS, PORT, 60)

print("கண்காணிப்பு டாஷ்போர்டு இயங்குகிறது...")

client.loop_forever()

முன்மாதிரியிலிருந்து உற்பத்தி வரை: MQTT சிறந்த நடைமுறைகள்

உங்கள் திட்டத்தை ஒரு எளிய ஸ்கிரிப்டிலிருந்து ஒரு வலுவான, அளவிடக்கூடிய உற்பத்தி அமைப்புக்கு நகர்த்துவதற்கு கவனமான திட்டமிடல் தேவை. இங்கே சில அத்தியாவசிய சிறந்த நடைமுறைகள் உள்ளன:

• ஒரு தெளிவான தலைப்பு படிநிலையை வடிவமைக்கவும்: ஆரம்பத்திலிருந்தே உங்கள் தலைப்பு கட்டமைப்பை கவனமாகத் திட்டமிடுங்கள். ஒரு நல்ல படிநிலை விளக்கமானது, அளவிடக்கூடியது, மற்றும் வைல்டு கார்டுகளைப் பயன்படுத்தி நெகிழ்வான சந்தாக்களுக்கு அனுமதிக்கிறது. ஒரு பொதுவான முறை <தளம்>/<பகுதி>/<சாதன_வகை>/<சாதன_ஐடி>/<அளவீடு> ஆகும்.
• நெட்வொர்க் துண்டிப்புகளை நளினமாகக் கையாளவும்: நெட்வொர்க்குகள் நம்பகமற்றவை. உங்கள் கிளையன்ட் குறியீடு வலுவான மீண்டும் இணைப்பு தர்க்கத்தை செயல்படுத்த வேண்டும். Paho-MQTT-யில் உள்ள `on_disconnect` கால்பேக் இதைத் தொடங்க சரியான இடம், நெட்வொர்க்கை மீண்டும் இணைப்பு முயற்சிகளால் நிரப்புவதைத் தவிர்க்க அதிவேக பின்வாங்கல் போன்ற ஒரு உத்தியை செயல்படுத்துகிறது.
• கட்டமைக்கப்பட்ட தரவு பேலோடுகளைப் பயன்படுத்தவும்: உங்கள் செய்தி பேலோடுகளுக்கு எப்போதும் JSON அல்லது புரோட்டோகால் பஃபர்கள் போன்ற ஒரு கட்டமைக்கப்பட்ட தரவு வடிவத்தைப் பயன்படுத்தவும். இது உங்கள் தரவை சுய-விளக்கமாகவும், பதிப்பு செய்யக்கூடியதாகவும், மற்றும் வெவ்வேறு பயன்பாடுகள் (எந்த மொழியில் எழுதப்பட்டிருந்தாலும்) எளிதாக அலசக்கூடியதாகவும் ஆக்குகிறது.
• இயல்பாகவே அனைத்தையும் பாதுகாக்கவும்: பாதுகாப்பு இல்லாமல் ஒரு IoT அமைப்பை வரிசைப்படுத்த வேண்டாம். குறைந்தபட்சம், பயனர்பெயர்/கடவுச்சொல் அங்கீகாரம் மற்றும் TLS குறியாக்கத்தைப் பயன்படுத்தவும். உயர் பாதுகாப்பு தேவைகளுக்கு, கிளையன்ட் சான்றிதழ் அடிப்படையிலான அங்கீகாரத்தை ஆராயுங்கள்.
• உங்கள் தரகரைக் கண்காணிக்கவும்: ஒரு உற்பத்தி சூழலில், உங்கள் MQTT தரகர் ஒரு முக்கியமான உள்கட்டமைப்பு பகுதியாகும். அதன் ஆரோக்கியத்தைக் கண்காணிக்க கண்காணிப்புக் கருவிகளைப் பயன்படுத்தவும், இதில் CPU/நினைவகப் பயன்பாடு, இணைக்கப்பட்ட கிளையன்ட்களின் எண்ணிக்கை, செய்தி விகிதங்கள் மற்றும் கைவிடப்பட்ட செய்திகள் ஆகியவை அடங்கும். பல தரகர்கள் இந்த நிலைத் தகவலை வழங்கும் ஒரு சிறப்பு `$SYS` தலைப்பு படிநிலையை வெளிப்படுத்துகின்றன.

முடிவுரை: பைத்தான் மற்றும் MQTT உடனான உங்கள் பயணம்

நாம் MQTT-யின் அடிப்படை "ஏன்" என்பதிலிருந்து, அதை பைத்தான் மூலம் செயல்படுத்துவதன் நடைமுறை "எப்படி" வரை பயணித்துள்ளோம். நீங்கள் வெளியிடு/சந்தாதாரர் மாதிரியின் சக்தி, QoS-ன் முக்கியத்துவம், மற்றும் பாதுகாப்பின் முக்கிய பங்கு பற்றி கற்றுக்கொண்டீர்கள். Paho-MQTT நூலகம் சென்சார் தரவை வெளியிடக்கூடிய மற்றும் கட்டளைகளுக்கு சந்தா செலுத்தக்கூடிய அதிநவீன கிளையன்ட்களை உருவாக்குவதை எவ்வளவு எளிதாக்குகிறது என்பதை நீங்கள் பார்த்தீர்கள்.

MQTT என்பது ஒரு நெறிமுறையை விட மேலானது; இது இன்டர்நெட் ஆஃப் திங்ஸிற்கான ஒரு அடித்தள தொழில்நுட்பம். அதன் இலகுவான தன்மை மற்றும் வலுவான அம்சங்கள் உலகெங்கிலும் உள்ள மில்லியன் கணக்கான சாதனங்களுக்கு, ஸ்மார்ட் நகரங்கள் முதல் இணைக்கப்பட்ட விவசாயம் முதல் தொழில்துறை ஆட்டோமேஷன் வரை, செல்ல வேண்டிய தேர்வாக ஆக்கியுள்ளன.

பயணம் இங்கே முடிவடைவதில்லை. அடுத்த படி, இந்தக் கருத்துக்களை எடுத்து நிஜ வன்பொருளில் பயன்படுத்துவது. ஒரு ராஸ்பெர்ரி பை, ஒரு ESP32, அல்லது பிற மைக்ரோகண்ட்ரோலர்களுடன் பரிசோதனை செய்யுங்கள். இயற்பியல் சென்சார்களை இணைக்கவும், கிளவுட் IoT தளங்களுடன் ஒருங்கிணைக்கவும், மற்றும் இயற்பியல் உலகத்துடன் தொடர்பு கொள்ளும் பயன்பாடுகளை உருவாக்கவும். பைத்தான் மற்றும் MQTT உடன், அடுத்த தலைமுறை இணைக்கப்பட்ட தீர்வுகளை உருவாக்க உங்களிடம் ஒரு சக்திவாய்ந்த கருவித்தொகுப்பு உள்ளது.