OPC-UA - (ESP8266, ESP32, Arduino + Ethernet)

I introduced OPC-UA architecture in more detail in the last published article. Today, I would like to extend the original article to include information and insights in the actual implementation. The implementation includes standard client → server communication, using various types of clients.

As for servers, they work on standard HTTP protocol 80, they differ mainly in operating modes, and they can operate on an existing LAN network as STATION, or they can broadcast their own encrypted WiFi network - AP mode - under WPA / WPA2 - PSK (Only applies to ESP8266 and ESP32).

To demonstrate such an OPC-UA architecture, I have chosen up to three platforms that can be combined into this architecture. These are the WiFi chips ESP8266 and ESP32, which provide WiFi connectivity and for Ethernet representative Arduino with the most famous Ethernet modules Wiznet W5100, W5500.

In my own implementation, I tried to create a full-fledged OPC-UA sensor system. The webserver receives data from the client - the ADC value of the converter, and distributes this data to other clients, so called. Subscribers who ask for this information by appropriate request. The system is very interesting as it can be implemented also in sensory networks, automation.

All data in the system is accessible in real time. The data is not stored, running on the webserver in its RAM memory. Webserver is also used for human interaction, as it is possible to connect to it from the browser, while it is possible to browse the data or control outputs via HTML page and its elements. The HTML page can also incorporate a simple SCADA visualization with the possibility of control through this visualization.

In implementation I used simple examples for HTTP webserver for each microprocessor architecture. I later extended the examples for the expected “requirements” (their form) to specific GET subpages. By implementing for all platforms, I managed to build a simple communication network that is multiplatform. I.e. If the Arduino webserver is equipped with an Ethernet shield, we can use the ESP8266 or ESP32 development boards as clients, as well as vice versa with a webserver on ESP platforms.

A simple block diagram represents the proposed architecture:

Server queries:

  • URL Function

  • / (Root) Overview of recent data + automatic refresh of data on the page

  • /data/?sensor_data=NUMBER Pass data to GET using NUMBER method (Publisher)

  • /get_data/ Request data from a server (Subscriber) from the server → value NUMBER

  • Web server types:*

  • Type Function

  • AP Broadcasts its own SSID network under WPA / WPA2 (can also be unsecured without a password), processes DHCP, static IP

  • STATION Connects to an existing WiFi / LAN network. It can have a dynamic IP, mDNS can be used for a domain name

  • Client types:*

  • Type Function

  • Publish_Client sends data from ADC converter to server, prints received server response - acknowledges received data sent

  • Publish_Client_UDP sends data from ADC converter to server, skip server response (process it, do not write received response, do not work with it)

  • Subscriber_Client performs an HTTP request to the server - the server responds with a received value from the (Publish) client, for example, the value can be a temperature. It is possible to work with the value, use it further (ventilation, boiler switching, relay)

  • Implementation issues:*
    The easiest implementation was to build the OPC-UA webserver for ESP8266. Directly in the examples for this platform is mentioned and pre-implemented also receiving the GET request for the page with the given parameter.

The ESP32 platform is little different in terms of software. There is another library header file, with server functions almost identical. Implementation on the ESP32 platform is somewhat different as it has no function for the expected parameter, as is the case with ESP8266. It can only accept the hard-coded parameter in the source code.

The hardest implementation was programming the web server for Arduino with Ethernet shield W5100 or W5500 module respectively. Each module uses a different library header file, for Wiznet W5100 it is Ethernet.h and for W5500 it is Ethernet2.h. The implementations for the webserver do not contain download parameters, they are able to download only the whole received string - request from client in style:

  • GET /data/?sensor_data=NUMBER*. This address needs to be split, for example with the C function strok (), or substring with the String object with appropriate terminators.

Then verify the individual depth and text of the URL, the received parameter and, last but not least, the value that the webserver should take. Arduino is considerably limited in terms of speed and memory. When using Arduina Uno, only 2kB of available RAM is available. ESP32 has 500kB of RAM and ESP8266 of about 96kB. The Arduino program with Ethernet module is quite specific, but it is possible to program a webserver equivalent to those used for ESP8266 or ESP32, as well as receive HTTP requests from these microcontrollers.

More about project you can see at: https://arduino.php5.sk/opc-ua-esp8266.php?lang=en

OPC-UA (Two ESP8266 and Windows Client communication)

Previous post is outdated...
Updated info below:
There is new concept for Web-service OPC-UA architecture that I am using.
Supported platforms:

  • Arduino + Ethernet shield Wiznet W5100
  • Arduino + Ethernet module Wiznet W5500
  • ESP8266 (NodeMCU, Wemos D1 Mini, Generic 8266-01/12E+)
  • ESP32 (DevKit), ESP32-S

Block schematics of my OPC-UA solution:

Webservers are now implemented only in STATION modes.
Payload is based on XML (SOAP) datas, from where webserver / client is parsing them.
Datas are sent under HTTP POST method only (NO GET MORE).
Locations (webpages) at webserver:

  • / - The root location ( or another based on your LAN settings), the page can be used by a client on a computer, other device, visualizes the last value from the client in the title

  • /body - data receiving page, expecting XML payload

  • /subscribe - Webserver will send XML payload to client (same as received from Publisher via /body webpage

Types of clients implemented in the project:

  • Publish_Client - sends data from ADC converter to server, prints received server response - acknowledges receipt of sent data

  • Subscriber_Client - performs an HTTP query to the server - the server responds with a received value from the client, for example, the value can be a temperature. It is possible to work with the value and use it (ventilation, boiler switching, relay)

Publish Client UDP is no longer supported.
Datas that user see (root page - /) with received datas throught /body

Webserver response to Subscriber client (Publisher is sending same XML document in payload [with new values and so on])

Codes for Webservers, and Webclients are fully compatible (working funcionality is same). Webclients can communicate only with OPC-UA webservers in that webaplication. They are not able to connect to PLC or some type of industrial OPC-UA server. They are not using TCP (binary) OPC-UA protocol! This is based on web-service OPC-UA (another architecture). Implementations are using in-built webserver, they are not using Async webservers and so on. This solution is the most lightweight as can be.

You can donate project for more examples, advanced implementations with using certificates, HTTPS connection, and so on (I am doing it for free at late evenings...): PayPal.Me

Source codes are available under MIT LICENSE at my Github repository: https://github.com/martinius96/OPC-UA-Arduino-ESP8266-ESP32/

More info about Web-service OPC-UA at my webpage: https://arduino.php5.sk/opc-ua-esp8266.php?lang=en