जेल्लास्टिक क्लाउड में Arduino सेंसर

क्लाउड कंप्यूटिंग के विकास के संबंध में नए ऑल-इनकमिंग इंटरनेट ऑफ थिंग्स (IoT) नेटवर्क का आगमन अब संभव हो गया है। IoT में, वास्तविक वस्तुओं का एक आभासी प्रतिनिधित्व होता है, जो हमें इंटरनेट पर उनके साथ बातचीत करने की अनुमति देता है। IoT में प्रासंगिक संसाधन क्लाउड कंप्यूटिंग के माध्यम से प्रदान किए जाते हैं। डिवाइस को एक-दूसरे से और इंटरनेट से कनेक्ट करना आपको अपने डेटा को दूरस्थ रूप से प्रबंधित करने की अनुमति देता है।
इसके लिए ऐसे अनुप्रयोगों की आवश्यकता होती है जो:

• उपकरणों के साथ डेटा के आदान-प्रदान के लिए एक आसान, खुला और सरल यूजर इंटरफेस प्रदान करना;
• IoT नेटवर्क में भाग लेने वाले कई उपकरणों के लगातार अनुरोधों को संभाल सकता है;
• नई सुविधाओं को प्रदान करने के लिए आसानी से विस्तार किया जा सकता है।

Jelastic PaaS, IoT नेटवर्क की सेवा करने वाले वेब अनुप्रयोगों की मेजबानी के लिए सबसे उपयुक्त प्लेटफार्मों में से एक है। यह वेब डेवलपर्स को वह सब कुछ प्रदान करता है जो उन्हें ऑनलाइन सेंसर से डेटा प्रबंधित करने वाले स्केलेबल एप्लिकेशन को जल्दी और आसानी से तैनात करने की आवश्यकता होती है। जेलस्टिक प्लेटफॉर्म इस समस्या का सबसे अच्छा समाधान है, क्योंकि यह एप्लिकेशन वातावरण, अपने स्वयं के डेटाबेस को बनाने और उपयोग करने की क्षमता, और यहां तक ​​कि स्थानीय फ़ाइल सिस्टम (Google ऐप इंजन के विपरीत) तक पहुंच प्रदान करता है।


आइए एक वेब एप्लिकेशन बनाने और तैनात करने का एक सरल उदाहरण देखें जो एक सेंसर से डेटा प्राप्त करता है और कल्पना करता है।

जेलस्टिक पर एक वातावरण बनाना

1. सबसे पहले, आपको अपने एप्लिकेशन के लिए वातावरण बनाना और कॉन्फ़िगर करना होगा। सेंसर से डेटा प्राप्त करने और कल्पना करने के उद्देश्य से, हमें एक एप्लिकेशन सर्वर (टॉमकैट 6) और एक डेटाबेस सर्वर (MySQL 5.0) की आवश्यकता है
   
   
   
   कुछ ही मिनटों में, एक वातावरण बनाया जाएगा। आपको एक पुष्टिकरण ईमेल भी मिलेगा, जिसमें आपके डेटाबेस के लिए यूज़रनेम और पासवर्ड और MySQL एडमिन पेज का लिंक शामिल होगा।
2. MySQL व्यवस्थापक पृष्ठ पर जाएं और सेंसर डेटा के लिए एक नया डेटाबेस बनाएं (सॉर्टिंग के बारे में चिंता न करें, हम सरल डेटा को संसाधित करने के लिए डेटाबेस का उपयोग करेंगे)।
   
   
   
   इस उदाहरण के लिए, हमें दो तालिकाओं की आवश्यकता है: एक सेंसर के बारे में जानकारी के लिए (उदाहरण के लिए, नाम या आईडी) और दूसरा सेंसर से डेटा के लिए।
   
   
   
   
   
   
   
   आप सभी विशेषाधिकारों के साथ एक नया उपयोगकर्ता भी बना सकते हैं, लेकिन हमारे मामले के लिए, आप डिफ़ॉल्ट उपयोगकर्ता का उपयोग कर सकते हैं।
   अब आपका पर्यावरण भरा हुआ है और आपके एप्लिकेशन और आपके डेटा के लिए कॉन्फ़िगर किया गया है।

जावा सर्वलेट बनाना

दूसरे चरण में एक जावा एप्लिकेशन विकसित करना शामिल है जो सेंसर से जानकारी प्राप्त करेगा और इसकी कल्पना करेगा। इस मामले के लिए, हमें दो सर्वलेट्स चाहिए: एक सेंसर से डेटा प्राप्त करने के लिए और दूसरा इसे विज़ुअलाइज़ करने के लिए।

1. एक्लिप्स IDE लॉन्च करें और एक नया डायनेमिक वेब प्रोजेक्ट बनाएं (जैसे JelasticSensorArduino ), एप्लिकेशन सर्वर के रूप में Tomcat चुनें।
2. प्रोजेक्ट खोलें और उपयुक्त सर्वलेट क्लास बनाएं (हम सुझाव देते हैं कि आप पैकेज पदानुक्रम पहले बनाएं)। एक JelasticArduinoServlet वर्ग बनाएं और इसमें निम्न कोड जोड़ें:
   
   

   1. आयात java.io.IOException ;
   2. आयात java.util.Date ;
   3. आयात javax.servlet.http। * ;
   4. आयात java.sql.Connection ;
   5. आयात java.sql.DriverManager ;
   6. आयात java.sql.ResultSet ;
   7. आयात java.sql.Statement ;
   9. @SuppressWarnings ( "धारावाहिक" )
   10. सार्वजनिक वर्ग JelasticArduinoServlet HttpServlet {
   11. सार्वजनिक शून्य doGet ( HttpServletRequest req, HttpServletResponse उत्तर )
   12. IOException { फेंकता है
   13. resp। setContentType ( "टेक्स्ट / प्लेन" ) ;
   15. // जीईटी अनुरोधों से सेंसर का नाम और मूल्य निकाल लें
   16. स्ट्रिंग SensorName = req। getParameter ( "सेंसर" ) ;
   17. स्ट्रिंग मूल्य = req। getParameter ( "value" ) ;
   18. // सर्वर से दिनांक मान प्राप्त करने के लिए एक नई तिथि ऑब्जेक्ट बनाएँ
   19. तारीख की तारीख = नई तारीख ( ) ;
   21. // Jelastic पर होस्ट किए गए MySQL DB में कनेक्शन स्ट्रिंग बनाएँ
   22. स्ट्रिंग url = "jdbc: mysql: //mysql.arduinocloud.jelastic.servint.net: 3306 / सेंसर" ;
   23. // यूजर डीबी से जुड़ने के लिए अपनी साख
   24. स्ट्रिंग उपयोगकर्ता = "DBUSERNAME" ;
   25. स्ट्रिंग पासवर्ड = "DBPASSWORD" ;
   27. कनेक्शन con = null ;
   28. कथन st = null ;
   29. परिणामी rs = null ;
   31. बूलियन मौजूद है = गलत ;
   32. int id = 0 ;
   33. // सर्वर से कनेक्शन बनाएं
   34. कोशिश करो {
   35. con = DriverManager । getConnection ( url, user, password ) ;
   36. st = con। createStatement ( ) ;
   37. // सेंसर आईडी प्राप्त करने के लिए क्वेरी निष्पादित करें
   38. आरएस = सेंट। executeQuery ( "सेंसर से सेलेक्ट आईडी जहां नाम = '" + सेंसरनाम + "';" ) ;
   40. अगर ( rs। अगला ( ) ) {
   41. मौजूद = सत्य ;
   42. id = rs getInt ( 1 ) ;
   43. }
   44. // यदि दिए गए सेंसर नाम के लिए एक आईडी है तो मूल्य को अपडेट करें
   45. अगर ( मौजूद है ) {
   46. सेंट। executeUpdate ( "डेटा में डालें (Sensid, date, value) VALUES ('" + id + ",'" + date + "','" + value + "'); )) ;
   47. }
   49. resp। getWriter ( ) । Println ( "सेंसर डेटा अपडेटेड!" ) ;
   51. चोर। करीब ( ) ;
   53. } पकड़ ( अपवाद पूर्व ) {
   54. resp। getWriter ( ) । Println ( ex exString ( ) ) ;
   55. }
   57. }
   58. }

   
   यह सर्वलेट के लिए कोड है जो सेंसर मानों के अपडेट को संभालता है। इसे Arduino या अपने ब्राउज़र का उपयोग करके बुलाया जा सकता है:
   http: //server.ip/servletname? Sens = sensorname & value = Sensvalue
   सबसे पहले, वह सेंसर डेटाबेस तक पहुँचता है और अपनी आईडी प्राप्त करता है। फिर ID अपने अनुसार टेबल डेटा को अपडेट करता है।
3. चलो जेएसपी फ़ाइल पर चलते हैं, जो सेंसर से डेटा की कल्पना करेगा। JSP फ़ाइल को आपके प्रोजेक्ट संरचना में WebContent फ़ोल्डर में बनाया जाना चाहिए। एक नई फ़ाइल बनाएं (उदा। Sensorgraph.jsp ):
   
   

   1. <% @ पृष्ठ contentType = "text / html; charset = UTF-8" भाषा = "जावा" %>
   2. <% @ पृष्ठ आयात = "java.util.List" %>
   3. <% @ पृष्ठ आयात = "java.sql.Connection" %>
   4. <% @ पृष्ठ आयात = "java.sql.DriverManager" %>
   5. <% @ पृष्ठ आयात = "java.sql.ResultSet" %>
   6. <% @ पृष्ठ आयात = "java.sql.Statement" %>
   8. < html >
   9. < सिर >
   10. < लिंक प्रकार = "टेक्स्ट / सीएसएस" rel = "स्टाइलशीट" href = " / स्टाइलशीट्स / main.css" />
   11. < script type = "text / javascript" src = " www.google.com/jsapi" > </ script >
   12. < script type = "text / javascript" >
   13. गूगल। लोड ( "विज़ुअलाइज़ेशन" , "1" , { पैकेज : [ "corechart" ] } ) ;
   14. गूगल। setOnLoadCallback ( drawChart ) ;
   15. समारोह ड्राचर्ट ( ) {
   16. var data = new google। दृश्य । डेटाटेबल ( ) ;
   17. डेटा। addColumn ( 'स्ट्रिंग' , 'टाइम' ) ;
   18. डेटा। addColumn ( 'संख्या' , '<% = request.getParameter ("सेंसर")%>' ) ;
   19. <%
   20. int काउंटर = 1 ;
   21. स्ट्रिंग SensorName = अनुरोध। getParameter ( "सेंसर" ) ;
   22. अगर ( SensorName == null ) {
   23. सेंसरनाम = " टेम्प " ;
   24. }
   26. स्ट्रिंग url = "jdbc: mysql: //mysql.arduinocloud.jelastic.servint.net: 3306 / सेंसर" ;
   27. स्ट्रिंग उपयोगकर्ता = "DBUSERNAME" ;
   28. स्ट्रिंग पासवर्ड = "DBPASSWORD" ;
   30. कनेक्शन con = null ;
   31. कथन st = null ;
   32. परिणामी rs = null ;
   34. बूलियन मौजूद है = गलत ;
   35. int id = 0 ;
   37. कोशिश करो {
   38. con = DriverManager । getConnection ( url, user, password ) ;
   39. st = con। createStatement ( ) ;
   40. आरएस = सेंट। executeQuery ( "सेंसर से सेलेक्ट आईडी जहां नाम = '" + सेंसरनाम + "';" ) ;
   42. अगर ( rs। अगला ( ) ) {
   43. मौजूद = सत्य ;
   44. id = rs getInt ( 1 ) ;
   45. }
   47. अगर ( मौजूद है ) {
   48. आरएस = सेंट। निष्पादित करें ( "डेटा से चयन करें जहां सेंसिड =" + आईडी ) ;
   50. जबकि ( rs। अगला ( ) ) {
   51. काउंटर ++;
   52. }
   53. %>
   54. डेटा। addRows ( <% = काउंटर %> ) ;
   55. <%
   56. आरएस = सेंट। निष्पादित करें ( "सही तिथि, डेटा से मूल्य जहां सेंसरिड =" + आईडी ) ;
   57. काउंटर = 0 ;
   58. जबकि ( rs। अगला ( ) ) {
   60. %>
   61. डेटा। setValue ( <% = काउंटर %> , 0 , '<% = rs.getString (1)%>' ) ;
   62. डेटा। setValue ( <% = काउंटर %> , 1 , <% = rs। getString ( 2 ) %> ) ;
   63. <%
   64. काउंटर ++;
   65. }
   67. }
   68. चोर। करीब ( ) ;
   69. } पकड़ ( अपवाद पूर्व ) { पूर्व। प्रिंटस्टैकट्रेस ( ) ; }
   71. %>
   73. var चार्ट = नया गूगल। दृश्य । LineChart ( दस्तावेज़। GetElementById ( 'chart_div' ) ) ;
   74. नहीं कर पाया। ड्रा ( डेटा, { चौड़ाई : 600 , ऊंचाई : 240 , शीर्षक : 'मेरा अरुडिनो <% = SensorName%> सेंसर रीडिंग' } ) ;
   75. }
   76. </ script >
   77. </ head >
   78. < शरीर >
   79. < p > </ p >
   80. < div id = "chart_div" > </ div >
   82. </ body >
   83. </ html >

   
   
   JSP डेटा ( चार्ट_डिव एलिमेंट) की कल्पना करने के लिए Google चार्ट एपीआई का उपयोग करता है। ऐसा करने के लिए, उसे डेटाबेस से मान निकालकर चार्ट के लिए डेटा के साथ फ़ील्ड भरना होगा।
   आपने देखा होगा कि HTML की शुरुआत में, कोड main.css नामक एक फ़ाइल में शामिल एक निश्चित सीएसएस शैली का उपयोग करता है। अपनी परियोजना में ऐसी फ़ाइल को शामिल करने के लिए, बस अपने प्रोजेक्ट के वेबकंटेंट / स्टाइलशीट सेक्शन में एक नया फ़ोल्डर बनाएँ।
   
   body {
font-family: Verdana, Helvetica, sans-serif;
background-color: #FFFFFF;
}

   
4. और अंतिम लेकिन कम से कम, आपको वेब . xml फ़ाइल ( WEB-INF फ़ोल्डर) को संपादित करने और JSP फ़ाइल के साथ सर्वलेट्स को संबद्ध करने के लिए संबंधित नाम-मैपिंग सर्वलेट बनाने की आवश्यकता है। निम्नलिखित के साथ web.xml की सामग्री को बदलें:
   
   

   1. <? xml संस्करण = "1.0 = एन्कोडिंग =" UTF-8। ?>
   3. <web-app xmlns: xsi = "http://www.w3.org/2001/XMLSchema-instance" xmlns = "http://java.sun.com/xml/ns/javaee" xmlns: web = http : //java.sun.com/xml/ns/javaee/web-app_2_5.xsd " xsi: schemaLocation =" http://java.sun.com/xml/ns/javaee http://java.sun.com /xml/ns/javaee/web-app_2_5.xsd " id =" WebApp_ID " संस्करण =" 2.5 / >
   5. <प्रदर्शन-नाम > JelasticSensorArduino </ display-name >
   7. <सर्वलेट >
   9. <सर्वलेट-नाम > जेल्लास्टिक अर्डुइनो </ सर्वलेट-नाम >
   11. <सर्वलेट-क्लास > doukas.jelastic.arduino.JelasticArduinoServlet </ सर्वलेट-क्लास >
   13. </ सर्वलेट >
   15. <सर्वलेट-मैपिंग >
   17. <सर्वलेट-नाम > जेल्लास्टिक अर्डुइनो </ सर्वलेट-नाम >
   19. <url-pattern > / jelasticarduino </ url-pattern >
   21. </ सर्वलेट-मैपिंग >
   23. <स्वागत-फ़ाइल-सूची >
   25. <स्वागत-फ़ाइल > sensorgraph.jsp </ स्वागत-फ़ाइल >
   27. </ स्वागत-फ़ाइल-सूची >
   29. <सर्वलेट >
   31. <सर्वलेट-नाम > जोड़ें </ सर्वलेट-नाम >
   33. <सर्वलेट-क्लास > doukas.jelastic.arduino.JelasticArduinoServlet </ सर्वलेट-क्लास >
   35. </ सर्वलेट >
   37. <सर्वलेट-मैपिंग >
   39. <सर्वलेट-नाम > जोड़ें </ सर्वलेट-नाम >
   41. <url-pattern > / add </ url-pattern >
   43. </ सर्वलेट-मैपिंग >
   45. </ वेब-ऐप >

   
   

आवेदन परिनियोजन और परीक्षण

अब आप यह देखने के लिए एक कदम दूर हैं कि आपका आवेदन कैसे प्राप्त करता है और सेंसर से डेटा की कल्पना करता है।

1. सबसे पहले, आपको जेल्लास्टिक वातावरण में एप्लिकेशन को तैनात करने के लिए अपने सर्वलेट्स के साथ एक डब्ल्यूएआर संग्रह बनाने की आवश्यकता होगी।
2. अपने WAR संग्रह को परिनियोजन प्रबंधक पर अपलोड करें।
   
   
3. अपने आवेदन को तैनात करें।
   
   
4. एक और छोटा विवरण: आपको mysql-कनेक्टर जार फ़ाइल डाउनलोड करने की आवश्यकता है।
   
   
   
   
   
5. चलो हमारे आवेदन का परीक्षण करें।
   
   ऐसा करने के लिए, निम्नलिखित लिंक ( सेंसरक्लाउड - पर्यावरण नाम) का पालन करें:
   http://sensorcloud.jelastic.servint.net/add?sensor=temp&value=20
   आपको एक संदेश दिखाई देगा: "सेंसर डेटा अपडेट किया गया!"। यदि यह मामला नहीं है (यह बहुत ही संभावना नहीं है यदि आपने सभी चरणों का सही ढंग से पालन किया है), तो आपको एक त्रुटि संदेश दिखाई देगा। पिछले लिंक का उपयोग करके कई सेंसर मान जोड़ें। फिर ग्राफ़ में देखे गए डेटा को देखने के लिए निम्न लिंक पर क्लिक करें:
   http://sensorcloud.jelastic.servint.net/?sensor=temp
   
   
6. अब यह एक कोड जोड़ने के लिए बना हुआ है जो सेंसर से डेटा पढ़ेगा और इसे डेटाबेस में बचाएगा।
   निम्नलिखित सी कोड ईथरनेट के माध्यम से जुड़े सेंसर से डेटा पढ़ता है और इसे आपके पर्यावरण के डेटाबेस में संग्रहीत करता है:
   
   

   1. # किंकर्तव्यविमू <SPI.h>
   3. #include <Ethernet.h>
   5. // नीचे अपने नियंत्रक के लिए एक मैक पता दर्ज करें।
   6. बाइट मैक [ ] = { 0x00 , 0xAA , 0xBB , 0xCC , 0xDE , 0xB2 } ;
   7. char serverName [ ] = "Senscloud.jelastic.servint.net" ;
   8. // इथरनेट क्लाइंट लाइब्रेरी को इनिशियलाइज़ करें
   9. ईथरनेट क्लाइंट ;
   11. शून्य सेटअप ( ) {
   12. // सीरियल लाइब्रेरी शुरू करें:
   13. सीरियल। शुरू ( 57600 ) ;
   14. // ईथरनेट कनेक्शन शुरू करें:
   15. अगर ( ईथरनेट शुरू होता है ) ( मैक ) == 0 ) {
   16. सीरियल। Println ( "डीएचसीपी का उपयोग करके ईथरनेट को कॉन्फ़िगर करने में विफल" ) ;
   17. }
   19. }
   21. शून्य लूप ( ) {
   23. int तापमान = analogRead ( 0 ) ;
   24. स्ट्रिंग s = स्ट्रिंग ( तापमान , DEC ) ;
   26. अगर ( क्लाइंट कनेक्ट । ( सर्वरनाम , 80 ) ) {
   27. // HTTP अनुरोध करें:
   28. ग्राहक। Println ( "GET / add? Sens = temp & value =" + s + "HTTP / 1.0" ) ;
   29. ग्राहक। Println ( "होस्ट: Senscloud.jelastic.servint.net" ) ;
   30. ग्राहक। Println ( ) ;
   31. ग्राहक। रोक ( ) ;
   32. }
   34. देरी ( 60000 ) ;
   35. }

   
   

इस प्रकार का एप्लिकेशन आपको सेंसर रीडिंग डाउनलोड करने का एक सीधा और सस्ता तरीका प्रदान करता है। आपको केवल Arduino जैसे नेटवर्क माइक्रोकंट्रोलर की आवश्यकता है, जो आसानी से URL तक पहुँच सकते हैं।

यह बहुत महत्वपूर्ण है कि जेलस्टिक आपको एप्लिकेशन की कार्यक्षमता पर ध्यान केंद्रित करने की अनुमति देता है और सेंसर मूल्यों को अद्यतन करने और सर्वर वातावरण को कॉन्फ़िगर करने के लिए आपके डेटा का बैकअप लेने के लिए एक साथ अनुरोधों की संख्या के बारे में चिंता नहीं करता है। जेलस्टिक सभी अतिरिक्त परेशानी को समाप्त करता है और आपके अनुप्रयोगों को तैनात करना और स्केल करना आसान बनाता है।

तैयारी में, आर्टिकल ऑफ थिंग्स के इंटरनेट के लिए जेल्लास्टिक का उपयोग करते हुए , अरुडिनो , सेंसर और क्लाउड के लेखक, चारलैम्पोस डौकास द्वारा एक लेख का उपयोग किया गया था।