Ruby and IoT: Industrial IoT Applications

Introduction

With the continuous advancement of technology, the Internet of Things (IoT) has been widely applied across various industries. Particularly in the industrial sector, IoT technology can help enterprises achieve intelligent management, improve production efficiency, and reduce costs. In this article, we will explore how to use the Ruby language to build a simple industrial IoT application.

What is Industrial IoT?

Industrial IoT (IIoT) refers to the connection of sensors, devices, and machines to the internet to collect, analyze, and share data. This connection allows enterprises to monitor equipment status in real-time, predict maintenance needs, and optimize production processes.

Introduction to Ruby

Ruby is a dynamic, object-oriented programming language known for its simplicity and readability. It is well-suited for rapid prototyping and has a rich library support that makes handling network requests and data storage easier.

Project Overview

In this project, we will create a simple IIoT application that can acquire temperature data from sensors and send this data to a server for storage. We will use the following components:

Sensor Simulation: Generates random temperature data.
HTTP Requests: Uses Ruby to send HTTP POST requests to transmit temperature data to the server.
Server-Side Reception: Sets up a simple web server with Ruby to receive and store this data.

Environment Setup

Ensure that you have the following software installed on your computer:

Ruby version 2.5 or above
Bundler (for managing Gems)
Sinatra (lightweight web framework)

You can install Sinatra using the following command:

gem install sinatra

Code Demonstration

1. Creating the Sensor Simulation Program

First, we need to create a data generation program that simulates a sensor. This program will generate random temperature values at intervals and send them to our web server via HTTP POST requests.

# sensor.rb
require 'net/http'
require 'json'
require 'securerandom'

def generate_random_temperature
  rand(15..30) # Generate a random temperature value between 15 and 30
end

def send_data_to_server(temperature)
  uri = URI('http://localhost:4567/temperature')
  response = Net::HTTP.post(uri, { id: SecureRandom.uuid, temperature: temperature }.to_json, "Content-Type" => "application/json")
  puts "Sent data: #{temperature}°C - Response: #{response.body}"
end

loop do
  temperature = generate_random_temperature()
  send_data_to_server(temperature)
  sleep(5) # Send data every 5 seconds
end

2. Creating a Web Server to Receive Temperature Data

Next, we need to create a simple web server to receive data from the sensor and store it. Here, we will only print the basic data, but you can extend the functionality as needed, such as saving it to a database.

# server.rb
require 'sinatra'
require 'json'

set :port, 4567 # Set the listening port to 4567

post '/temperature' do
  request.body.rewind
  data = JSON.parse(request.body.read)
  puts "Received data from ID #{data['id']}: Temperature is #{data['temperature']}°C"
  status :ok # Return 200 status code to indicate successful processing
end

Starting the Service and Testing

First, start our web server in the terminal:
```
ruby server.rb
```
Then, in another terminal window, run the sensor simulation program:
```
ruby sensor.rb
```
At this point, you should see a new temperature record output in the terminal every five seconds, and the web server in the first window will also display the received data.

Conclusion and Outlook

This article introduced how to use Ruby to build a basic industrial IoT application, including simulating sensors, sending HTTP requests, and setting up a simple web service. This is just a small part of IIoT; actual applications may involve more complex functionalities, such as security considerations, real-time monitoring interfaces, etc. We hope this article inspires you to explore IoT development further!