Beckhoff.TwinCAT.Ads.AdsOverMqtt 6.2.244

Description

The package 'Beckhoff.TwinCAT.Ads.AdsOverMqtt' contains a protocol plugIn for ADS-OVER-MQTT that allows AdsClients and AdsServer to communicate transparently without TwinCAT Router via an existing MQTT Publisher.

Requirements

• .NET 8.0 or .NET 6.0 compatible SDK. .NET Standard 2.0 is not supported!
• A running MQTT Broker Server

Installation

Place a dependency of this package in your application.

Version Support lifecycle

[^1]: Requirement on the Host system. No version limitation in remote system communication. [^2]: Microsoft support for .NET5 ends with May 8, 2022. Therefore it is recommended to update Beckhoff.TwinCAT packages from Version 5 to Version 6.

Migrating to the latest .NET Microsoft .NET support lifecycle

First Steps

Have an MQTT Publisher connecting TwinCAT Systems via ADS-OVER-MQTT available (e.g an TwinCAT Cloud instance). Reference the Beckhoff.TwinCAT.Ads.AdsOverMqtt package from your project beneath references to Beckhoff.TwinCAT.Ads or Beckhoff.TwinCAT.Ads.AdsServer packages. Just by MEF Plug functionality (having the TwinCAT.Ads.AdsOverMqtt.dll assembly in the applications binaries folder), ADS is communication via ADS-OVER-MQTT transparently. As effect, no TwinCAT Router is necessary anymore.

Activation of Ads-Over-Mqtt

Reference the following Packages to your application (AdsOverMqtt plugIn) AdsOverMqtt: Protocol as PlugIn ConfigurationProviders: StaticRoutes configuration provider

<ItemGroup>
    <PackageReference Include="Beckhoff.TwinCAT.Ads.AdsOverMqtt" Version="6.2.86" />
    <PackageReference Include="Beckhoff.TwinCAT.Ads.ConfigurationProviders" Version="6.2.86" />-->
</ItemGroup>

    using Microsoft.Extensions.DependencyInjection;
    using Microsoft.Extensions.Hosting;
    using Microsoft.Extensions.Logging;
    using System.Threading.Tasks;
    using TwinCAT.Ads.ConfigurationProviders;

    class Program
    {
        /// <summary>
        /// Defines the entry point of the application.
        /// </summary>
        /// <param name="args">The arguments.</param>
        public async static Task Main(string[] args)
        {
            var ret = CreateHostBuilder(args);
            await ret.RunConsoleAsync();
        }

        /// <summary>
        /// Creates the host builder.
        /// </summary>
        /// <param name="args">The arguments.</param>
        /// <returns>IHostBuilder.</returns>
        public static IHostBuilder CreateHostBuilder(string[] args)
        {
            var ret = Host.CreateDefaultBuilder(args);

            ret.ConfigureServices((hostContext, services) =>
            {
                services.AddHostedService<AdsOverMqttService>();
            })
            .ConfigureAppConfiguration((hostingContext, config) =>
            {
                // Add further AppConfigurationProvider here.
                //config.Sources.Clear(); // Clear all default config sources 
                //config.AddEnvironmentVariables("ADSOVERMQTT_"); // Use Environment variables
                //config.AddCommandLine(args); // Use Command Line
                //config.AddJsonFile("appSettings.json"); // Use Appsettings
                config.AddStaticRoutesXmlConfiguration(); // Overriding settings with StaticRoutes.Xml 
            })
            .ConfigureLogging(logging =>
            {
                logging.ClearProviders();
                // Adding console logging here.
                logging.AddConsole();
            });
            return ret;
        }
    }

using System;
using System.Threading.Tasks;
using System.Threading;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using TwinCAT.Ads;

namespace AdsOverMqtt
{

    /// <summary>
    /// The RouterService instance represents a long running (hosted) service that implements an <see cref="AmsTcpIpRouter"/>.
    /// Implements the <see cref="BackgroundService" />
    /// </summary>
    /// <remarks>
    /// Long running Background task that runs a <see cref="AmsTcpIpRouter."/>.
    /// The service is stopped via the <see cref="CancellationToken"/> given to the <see cref="ExecuteAsync(CancellationToken)"/> method.
    /// </remarks>
    /// <seealso cref="BackgroundService" />
    public class AdsOverMqttService : BackgroundService
    {
        /// <summary>
        /// Logger
        /// </summary>
        private readonly ILogger<AdsOverMqttService> _logger;
        /// <summary>
        /// Configuration
        /// </summary>
        private readonly IConfiguration _configuration;

        /// <summary>
        /// Initializes a new instance of the <see cref="RouterService"/> class.
        /// </summary>
        /// <param name="logger">The logger.</param>
        /// <param name="configuration">The configuration.</param>
        public AdsOverMqttService(ILogger<AdsOverMqttService> logger, IConfiguration configuration)
        {
            _logger = logger;
            _configuration = configuration;
            //string? value = _configuration.GetValue("ASPNETCORE_ENVIRONMENT", "Production");
        }

        /// <summary>
        /// Execute the Router asynchronously as <see cref="BackgroundService"/>.
        /// </summary>
        /// <param name="cancel">The cancellation token.</param>
        protected override async Task ExecuteAsync(CancellationToken cancel)
        {
            AmsAddress targetAddress = new AmsAddress("1.2.3.4.1.1", 851); // Address to Cloud target

            try
            {
                using (var session = new AdsSession(targetAddress, SessionSettings.Default, _configuration, null, null))
                {
                    var connection = (IAdsConnection)session.Connect();

                    while (!cancel.IsCancellationRequested)
                    {
                        var result = await connection!.ReadValueAsync<short>("MAIN.i", cancel);

                        if (result.Succeeded)
                        {
                            Console.WriteLine($"Value: {result.Value}");
                        }
                        else
                        {
                            Console.WriteLine($"AdsError: {result.ErrorCode}");
                        }
                        await Task.Delay(200); // Delay of 200 ms
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
            Console.WriteLine("Finished");
        }
    }
}

Further documentation

The actual version of the documentation is available in the Beckhoff Infosys: Beckhoff Information System

Sample Code

A Client Sample implementation can be found here: Beckhoff GitHub AdsOverMqttApp

More dedicated information about using this component in Docker: Beckhoff GitHub Docker Samples