Cómo crear un cliente para el servidor PLCnext Control gRPC en C#

La versión de firmware 2022.0 LTS presenta un servidor gRPC en los dispositivos AXC F 1152 y AXC F 2152. Este servidor gRPC proporciona una forma para que las aplicaciones cliente accedan a los servicios RSC en el dispositivo PLCnext Control. Las aplicaciones cliente pueden ser:

• Escrito en cualquier idioma compatible con gRPC.
• Ejecutar en cualquier lugar:localmente en el dispositivo PLCnext Control o en una máquina remota*.
• Alojado en un contenedor OCI.

(* el acceso remoto estará disponible a partir de la versión de firmware 2022.3)

La información general sobre el servidor gRPC en los dispositivos PLCnext Control está disponible en el centro de información de PLCnext.

Este artículo describe cómo crear una aplicación de cliente gRPC simple en C#, ejecutándose en un dispositivo PLCnext Control.

Requisitos

El siguiente procedimiento utiliza:

• AXC F 2152 con la versión de firmware 2022.0.3 LTS o posterior.
• PLCnext Engineer versión 2022.0.1 LTS o posterior.
• Visual Studio 2019 (cualquier edición).
• Los conceptos presentados en esta publicación del blog Makers:Cómo crear una aplicación de consola PLCnext simple en C#
• Archivos de definición de protobuf para el servidor gRPC, en el directorio protobuf del repositorio PLCnext/gRPC Github.
• El servicio RSC de estado del dispositivo.
• El servicio RSC de acceso a datos.

Procedimiento

1. Usando la página de administración basada en web, asegúrese de que el servicio denominado GRPC LOCAL SERVER esté activado.

2. Cree un nuevo proyecto PLCnext Engineer para su dispositivo de destino. Este proyecto debe tener:

• Un programa con una variable de puerto de SALIDA llamada AI1, de tipo INT.
• Una instancia de ese programa llamada MainInstance1.

3. Envíe el proyecto PLCnext Engineer al dispositivo de destino.

4. En Visual Studio, cree una aplicación de consola C# vacía siguiendo los pasos 1 a 3 del procedimiento descrito en la publicación anterior del Blog Makers.

5. En la ventana Proyecto => Propiedad, establezca el marco de destino del proyecto en ".NET 5.0".

6. En el Explorador de soluciones, haga clic con el botón derecho en la solución, seleccione "Administrar paquetes NuGet para la solución..." e instale los siguientes paquetes NuGet:

• Grpc.Herramientas
• Grpc.Net.Cliente
• Google.Protobuf

7. Copie la carpeta protobuf que contiene los archivos de definición de protobuf en la carpeta de origen del proyecto. Protobuf es el lenguaje de definición de interfaz (IDL) que se utiliza para describir los servicios de gRPC.

8. En el archivo de configuración del proyecto, agregue una referencia a los archivos .proto para los servicios que se utilizarán en el proyecto. La sección ItemGroup de la configuración del proyecto ahora se verá así:

9. Reemplace el contenido del archivo .cs del proyecto con este código (es posible que deba cambiar el nombre del espacio de nombres):

using System;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using System.IO;
using Grpc.Net.Client;
using Arp.Device.Interface.Services.Grpc;
using Arp.Plc.Gds.Services.Grpc;

namespace ConsoleApp1
{
	class Program
	{
		static void Main()
		{
			// The code to connect to a Unix Domain Socket is from:
			// https://docs.microsoft.com/en-us/aspnet/core/grpc/interprocess?view=aspnetcore-6.0

			var udsEndPoint = new UnixDomainSocketEndPoint("/run/plcnext/grpc.sock");
			var connectionFactory = new UnixDomainSocketConnectionFactory(udsEndPoint);
			var socketsHttpHandler = new SocketsHttpHandler
			{
				ConnectCallback = connectionFactory.ConnectAsync
			};

			// Create a gRPC channel to the PLCnext unix socket
			using var channel = GrpcChannel.ForAddress("http://localhost", new GrpcChannelOptions
			{
				HttpHandler = socketsHttpHandler
			});

			// Create a gRPC client for the Device Status Service on that channel
			var grpc_status_client = new IDeviceStatusService.IDeviceStatusServiceClient(channel);

			// Create a gRPC client for the Data Access Service on that channel
			var grpc_data_client = new IDataAccessService.IDataAccessServiceClient(channel);

			// Create an item to get from the Device Status Service
			// Item identifiers are listed in the PLCnext Info Center:
			// https://www.plcnext.help/te/Service_Components/Remote_Service_Calls_RSC/RSC_device_interface_services.htm#IDeviceStatusService

			var item = new IDeviceStatusServiceGetItemRequest();
			item.Identifier = "Status.Board.Temperature.Centigrade";

			// Create a variable to get from the Data Access Service
			var data = new IDataAccessServiceReadSingleRequest();
			data.PortName = "Arp.Plc.Eclr/MainInstance1.AI1";

			// Response variables
			IDeviceStatusServiceGetItemResponse grpc_status_response;
			IDataAccessServiceReadSingleResponse grpc_data_response;

			// Endless loop
			while (true)
			{
				// Request the item from the Device Status Service
				grpc_status_response = grpc_status_client.GetItem(item);

				// Request data from the Data Access Service
				grpc_data_response = grpc_data_client.ReadSingle(data);

				// Report the results
				var temperature = grpc_status_response.ReturnValue.Int8Value;
				var ai1 = grpc_data_response.ReturnValue.Value.Int16Value;

				Console.WriteLine("Board Temperature = " + temperature + "°C");
				Console.WriteLine("MainInstance1.AI1 = " + ai1);

				// Wait for 1 second
				Thread.Sleep(1000);
			}
		}
	}

	public class UnixDomainSocketConnectionFactory
	{
		private readonly EndPoint _endPoint;

		public UnixDomainSocketConnectionFactory(EndPoint endPoint)
		{
			_endPoint = endPoint;
		}

		public async ValueTask<Stream> ConnectAsync(SocketsHttpConnectionContext _,
			CancellationToken cancellationToken = default)
		{
			var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);

			try
			{
				await socket.ConnectAsync(_endPoint, cancellationToken).ConfigureAwait(false);
				return new NetworkStream(socket, true);
			}
			catch
			{
				socket.Dispose();
				throw;
			}
		}
	}
}

10. En el Explorador de soluciones, haga clic con el botón derecho en la Solución y abra una Terminal.

11. En la terminal, ejecuta los siguientes comandos:

dotnet build ConsoleApp1.csproj
dotnet publish -c RELEASE -r linux-arm .\ConsoleApp1.csproj -o MyApp

… donde ConsoleApp1 es el nombre de la solución y MyApp es el nombre del directorio de salida donde se publicará la aplicación. La aplicación también se puede publicar en modo DEBUG si es necesario.

12. Copie el directorio de salida y todo su contenido al PLC usando (por ejemplo) scp o WinSCP.

scp -r MyApp [email protected]:~

13. Abra una sesión de shell en el PLC usando (por ejemplo) ssh o PuTTY.

14. Asegúrese de que el ejecutable tenga privilegios de ejecución:

$ chmod a+x /opt/plcnext/MyApp/ConsoleApp1

15. Ejecute la aplicación:

$ /opt/plcnext/MyApp/ConsoleApp1

La salida debe ser similar a:

Board Temperature = 50°C
MainInstance1.AI1 = 0
Board Temperature = 50°C
MainInstance1.AI1 = 0
Board Temperature = 50°C
MainInstance1.AI1 = 0
Board Temperature = 50°C
MainInstance1.AI1 = 0

16. En PLCnext Engineer, conéctese y cambie el valor de la variable AI1. El valor informado por la aplicación debería cambiar.

Referencias y otros recursos

1. .NET Core ❤ gRPC

2. Llame a los servicios gRPC con el cliente .NET

3. Una lista seleccionada de recursos útiles para gRPC