Arduino sensors in Jelastic Cloud

The emergence of a new comprehensive network of Internet of Things (IoT) has now become possible due to the development of cloud computing. In IoT, real objects have a virtual presentation that allows us to interact with them via the Internet. Relevant resources in IoT are provided using cloud computing. Connecting devices to each other and to the Internet allows you to manage your data remotely.
This requires applications that:

• provide an easy, open and simple user interface for communicating with devices;
• can handle frequent requests from multiple devices that participate in the IoT network;
• can be easily expanded to provide new features.

Jelastic PaaS is one of the most suitable platforms for hosting web applications that serve IOT networks. It provides web developers with everything they need to quickly and easily deploy scalable applications that manage sensor data online. Jelastic platform is the best solution to this problem, because it provides full access to the application environment, the ability to create and use your own database and even access to the local file system (unlike Google App Engine).


Let's look at a simple example of creating and deploying a web application that receives and visualizes data from a sensor.

Creating an environment on Jelastic

1. First, you must create and configure the environment for your application. In order to obtain and visualize data from sensors, we need an application server (Tomcat 6) and a database server (MySQL 5.0)
   
   
   
   In a few minutes, an environment will be created. You will also receive a confirmation email that will include your username and password for your database and a link to the MySQL admin page.
2. Go to the MySQL admin page and create a new database for the sensor data (do not worry about sorting, we will use the database to process simple data).
   
   
   
   For this example, we need two tables: one for information about the sensor (for example, name or id) and the second for data from the sensor.
   
   
   
   
   
   
   ')
   You can also create a new user with all privileges, but in our case, you can use the default user.
   Now your environment is complete and configured for your application and your data.

Creating a Java Servlet

The second step involves developing a Java application that will receive information from the sensor and visualize it. For this case, we need two servlets: one to receive data from the sensor and the second to visualize it.

1. Launch the Eclipce IDE and create a new Dynamic Web Project (for example, JelasticSensorArduino ), select Tomcat as the application server.
2. Open the project and create the appropriate servlet class (we suggest you create the package hierarchy first). Create a JelasticArduinoServlet class and add the following code to it:
   
   

   1. import java.io.IOException ;
   2. import java.util.Date ;
   3. import javax.servlet.http. * ;
   4. import java.sql.Connection ;
   5. import java.sql.DriverManager ;
   6. import java.sql.ResultSet ;
   7. import java.sql.Statement ;
   9. @SuppressWarnings ( "serial" )
   10. public class JelasticArduinoServlet extends HttpServlet {
   11. public void doGet ( HttpServletRequest req, HttpServletResponse resp )
   12. throws IOException {
   13. resp. setContentType ( "text / plain" ) ;
   15. // Retrieve the GET requests
   16. String SensorName = req. getParameter ( "sensor" ) ;
   17. String value = req. getParameter ( "value" ) ;
   18. // Create a new date from the server
   19. Date date = new Date ( ) ;
   21. // Create MySQL DB hosted on Jelastic
   22. String url = "jdbc: mysql: //mysql.arduinocloud.jelastic.servint.net: 3306 / sensor" ;
   23. // User your credential for connecting to the DB
   24. String user = "DBUSERNAME" ;
   25. String password = "DBPASSWORD" ;
   27. Connection con = null ;
   28. Statement st = null ;
   29. ResultSet rs = null ;
   31. boolean exists = false ;
   32. int id = 0 ;
   33. // Make the connection to the server
   34. try {
   35. con = drivermanager . getConnection ( url, user, password ) ;
   36. st = con. createStatement ( ) ;
   37. // Execute the sensor for the sensor id
   38. rs = st. executeQuery ( "SELECT id from sensor where name = '" + SensorName + "';" ) ;
   40. if ( rs. next ( ) ) {
   41. exists = true ;
   42. id = rs. getInt ( 1 ) ;
   43. }
   44. // If there is an ID
   45. if ( exists ) {
   46. st. executeUpdate ( "Insert into data (sensor, date, value) VALUES ('" + id + "', '" + date + "', '" + value + "');" ) ;
   47. }
   49. resp. getWriter ( ) . println ( "Sensor data updated!" ) ;
   51. con. close ( ) ;
   53. } catch ( Exception ex ) {
   54. resp. getWriter ( ) . println ( ex. toString ( ) ) ;
   55. }
   57. }
   58. }

   
   This is the servlet code that handles updates to the sensor values. It can be invoked using Arduino or your browser:
   http: //server.ip/servletname? sensor = sensorname & value = sensorvalue
   First, it accesses the sensor database and gets its ID. The ID then updates the table data accordingly.
3. Let's go to the JSP file , which will visualize the data from the sensor. The JSP file must be created in the WebContent folder in your project structure. Create a new file (for example, sensorgraph.jsp ):
   
   

   1. <% @ page contentType = "text / html; charset = UTF-8" language = "java" %>
   2. <% @ page import = "java.util.List" %>
   3. <% @ page import = "java.sql.Connection" %>
   4. <% @ page import = "java.sql.DriverManager" %>
   5. <% @ page import = "java.sql.ResultSet" %>
   6. <% @ page import = "java.sql.Statement" %>
   8. < html >
   9. < head >
   10. < link type = "text / css" rel = "stylesheet" href = "/stylesheets/main.css" />
   11. < script type = "text / javascript" src = " www.google.com/jsapi" > </ script >
   12. < script type = "text / javascript" >
   13. google. load ( "visualization" , "1" , { packages : [ "corechart" ] } ) ;
   14. google. setOnLoadCallback ( drawChart ) ;
   15. function drawChart ( ) {
   16. var data = new google. visualization . DataTable ( ) ;
   17. data. addColumn ( 'string' , 'Time' ) ;
   18. data. addColumn ( 'number' , '<% = request.getParameter ("sensor")%>' ) ;
   19. <%
   20. int counter = 1 ;
   21. String SensorName = request. getParameter ( "sensor" ) ;
   22. if ( SensorName == null ) {
   23. SensorName = "temp" ;
   24. }
   26. String url = "jdbc: mysql: //mysql.arduinocloud.jelastic.servint.net: 3306 / sensor" ;
   27. String user = "DBUSERNAME" ;
   28. String password = "DBPASSWORD" ;
   30. Connection con = null ;
   31. Statement st = null ;
   32. ResultSet rs = null ;
   34. boolean exists = false ;
   35. int id = 0 ;
   37. try {
   38. con = drivermanager . getConnection ( url, user, password ) ;
   39. st = con. createStatement ( ) ;
   40. rs = st. executeQuery ( "SELECT id from sensor where name = '" + SensorName + "';" ) ;
   42. if ( rs. next ( ) ) {
   43. exists = true ;
   44. id = rs. getInt ( 1 ) ;
   45. }
   47. if ( exists ) {
   48. rs = st. executeQuery ( "SELECT value from data where sensorid =" + id ) ;
   50. while ( rs. next ( ) ) {
   51. counter ++;
   52. }
   53. %>
   54. data. addRows ( <% = counter %> ) ;
   55. <%
   56. rs = st. executeQuery ( "SELECT date, value from data where sensorid =" + id ) ;
   57. counter = 0 ;
   58. while ( rs. next ( ) ) {
   60. %>
   61. data. setValue ( <% = counter %> , 0 , '<% = rs.getString (1)%>' ) ;
   62. data. setValue ( <% = counter %> , 1 , <% = rs. getString ( 2 ) %> ) ;
   63. <%
   64. counter ++;
   65. }
   67. }
   68. con. close ( ) ;
   69. } catch ( Exception ex ) { ex. printStackTrace ( ) ; }
   71. %>
   73. var chart = new google. visualization . LineChart ( document. GetElementById ( 'chart_div' ) ) ;
   74. chart. draw ( data, { width : 600 , height : 240 , title : 'My Arduino <% = SensorName%> Sensor Readings' } ) ;
   75. }
   76. </ script >
   77. </ head >
   78. < body >
   79. < p > </ p >
   80. < div id = "chart_div" > </ div >
   82. </ body >
   83. </ html >

   
   
   JSP uses the Google Chart API to visualize data ( chart_div element). To do this, it needs to fill in the data fields for the chart by retrieving values ​​from the database.
   You may have noticed that at the beginning of the HTML code uses a specific CSS style included in a file called main.css . To include such a file in your project, simply create a new folder in the WebContent / stylesheets section of your project.
   
   body {
font-family: Verdana, Helvetica, sans-serif;
background-color: #FFFFFF;
}

   
4. Last but not least, you need to edit the web.xml file ( WEB-INF folder) and create the corresponding name-mapping servlet to associate the servlets with the JSP file. Replace web.xml with the following:
   
   

   1. <? xml version = “1.0 ″ encoding =“ 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 ” version =“ 2.5 ″ >
   5. <display-name > JelasticSensorArduino </ display-name >
   7. <servlet >
   9. <servlet-name > JelasticArduino </ servlet-name >
   11. <servlet-class > doukas.jelastic.arduino.JelasticArduinoServlet </ servlet-class >
   13. </ servlet >
   15. <servlet-mapping >
   17. <servlet-name > JelasticArduino </ servlet-name >
   19. <url-pattern > / jelasticarduino </ url-pattern >
   21. </ servlet-mapping >
   23. <welcome-file-list >
   25. <welcome-file > sensorgraph.jsp </ welcome-file >
   27. </ welcome-file-list >
   29. <servlet >
   31. <servlet-name > add </ servlet-name >
   33. <servlet-class > doukas.jelastic.arduino.JelasticArduinoServlet </ servlet-class >
   35. </ servlet >
   37. <servlet-mapping >
   39. <servlet-name > add </ servlet-name >
   41. <url-pattern > / add </ url-pattern >
   43. </ servlet-mapping >
   45. </ web-app >

   
   

Deploy and test the application

Now you are one step away from seeing how your application receives and visualizes data from the sensor.

1. First, you will need to create a WAR archive with your servlets to deploy the application in Jelastic environment.
2. Upload your WAR archive to the Deployment Manager .
   
   
3. Deploy your application.
   
   
4. Another small detail: you need to load the mysql-connector jar file.
   
   
   
   
   
5. Let's test our application.
   
   To do this, follow the following link ( sensorcloud - the name of the environment):
   http://sensorcloud.jelastic.servint.net/add?sensor=temp&value=20
   You will see the message: “Sensor data updated!”. If this is not the case (it is very unlikely if you completed all the steps correctly), you will see an error message. Add multiple sensor values ​​using the previous link. Then go to the following link to see the visualized data as a graph:
   http://sensorcloud.jelastic.servint.net/?sensor=temp
   
   
6. Now it remains to add a code that will read data from the sensor and save them to the database.
   The following C code reads data from a sensor connected via Ethernet and stores it in the base of your environment:
   
   

   1. #include <SPI.h>
   3. #include <Ethernet.h>
   5. // Enter a MAC address for your controller below.
   6. byte mac [ ] = { 0x00 , 0xAA , 0xBB , 0xCC , 0xDE , 0x02 } ;
   7. char serverName [ ] = "sensorcloud.jelastic.servint.net" ;
   8. // Initialize the Ethernet client library
   9. Ethernet Client ;
   11. void setup ( ) {
   12. // start the serial library:
   13. Serial. begin ( 57600 ) ;
   14. // start the Ethernet connection:
   15. if ( ethernet. begin ( mac ) == 0 ) {
   16. Serial. println ( "Failed to configure Ethernet using DHCP" ) ;
   17. }
   19. }
   21. void loop ( ) {
   23. int temperature = analogRead ( 0 ) ;
   24. String s = String ( temperature , DEC ) ;
   26. if ( client. connect ( serverName , 80 ) ) {
   27. // Make a HTTP request:
   28. client. println ( "GET / add? sensor = temp & value =" + s + "HTTP / 1.0" ) ;
   29. client. println ( "Host: sensorcloud.jelastic.servint.net" ) ;
   30. client. println ( ) ;
   31. client. stop ( ) ;
   32. }
   34. delay ( 60000 ) ;
   35. }

   
   

Applications of this type provide you with a direct and affordable way to download sensor readings. All you need is a network microcontroller, such as an Arduino , that can easily access URLs.

It is very important that Jelastic allows you to concentrate on the functionality of the application and does not worry about the number of simultaneous requests for updating sensor values ​​and setting up a server environment for creating backup copies of your data. Jelastic eliminates all the extra hassle and makes it easy to deploy and scale your applications.

In preparing the article was used Charalampos Doukas, author of the book "Arduino, Sensors and the Cloud" , Using Jelastic for the Internet of Things .