AmsTcpIpRouter Class

Inheritance Hierarchy

System.Object
  TwinCAT.Ads.TcpRouter.AmsTcpIpRouter

Namespace: TwinCAT.Ads.TcpRouter
Assembly: TwinCAT.Ads.TcpRouter (in TwinCAT.Ads.TcpRouter.dll) Version: 7.0.0+e56d35ccc4675faac24789a4aab60071fc61d470

C#

public class AmsTcpIpRouter : IAmsRouter

The AmsTcpIpRouter type exposes the following members.

Properties

Methods

Events

Fields

Remarks

The AmsTcpIpRouter implements a simple ADS/AMS Router for systems, where no TwinCAT Router installation is available.

The Router opens two different type of communication channels With this infrastructure, the AmsTcpIpRouter is able to process ADS/AMS communication in form of ADS Requests and Responses not only isolated on the local system, but also between the local system and remote systems as long they are properly configured.

• One for the machine internal communication between AdsClients and AdsServers. This is called the **ADS Loopback** port and has by default the IPAddress.Loopback (172.0.0.1) and Port 0xBF02 (RouterLoopbackPort)
• The other that routes the machine external communication to other TwinCAT ADS routers. This **ADS External Channel** is opened by default on every available IPAddress connected to a Network again on default Port 0xBF02. A **StaticRoutes** table (e.g. the StaticRoutes.xml of every TwinCAT System) is used to ensure security and maintain the list of remote target systems.

For sophisticated scenarious, the default configurations can be changed to also support more than one router on one system and/or split Client/Server/Router applications in virtual environments like docker.

The router settings can be configured by the .NET Configuration Builder IConfigurationBuilder or simply by calling one of the AmsTcpIpRouter constructor overloads.

Example

The following sample shows how to use the AmsTcpIpRouter class within an own Console application. This console application can also be accessed as binary from the Nuget.org package repository. The ID of the package is 'Beckhoff.TwinCAT.Ads.AdsRouterConsole'.

Ads Router WorkerService

class Program
{
    /// <summary>
    /// Defines the entry point of the application.
    /// </summary>
    /// <param name="args">The arguments.</param>
    public static void Main(string[] args)
    {
    try
    {
        CreateHostBuilder(args).Build().Run();
    }
    catch (OperationCanceledException /*cex*/)
    {
        Console.WriteLine("Router cancelled!");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Router failed with '{ex.Message}'");
    }
    }

    /// <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);

        // Create a configuration for the custom logger
        // var loggerConfig = new AdsLoggerConfiguration
        // {
        //     LogLevel = Environment.GetEnvironmentVariable("Logging:LogLevel:Default");
        //     EventId = 0
        // };

        //var loggerConfig = AdsLoggerConfiguration.CreateFromEnvironment();
        //var loggerConfig2 = AdsLoggerConfiguration.CreateFromConfiguration();

        // // Create an ILoggerFactory and add the custom logger provider
        // var loggerFactory = LoggerFactory.Create(builder =>
        // {
        //     builder.SetMinimumLevel(LogLevel.Information)
        //     .AddProvider(new AdsLoggerProvider(() => loggerConfig));
        // });

        ret.ConfigureServices((hostContext, services) =>
        {
        services.AddHostedService<RouterService>();
        })
        .ConfigureAppConfiguration((hostingContext, config) =>
        {
        // Add further AppConfigurationProvider here.
        config.Sources.Clear(); // Clear all default config sources 
        //config.AddEnvironmentVariables("ENV_"); // Use Environment variables
        config.AddEnvironmentVariables(""); // Use Environment variables
        //config.AddCommandLine(args); // Use Command Line
        //config.AddJsonFile("appSettings.Development.json"); // Use Appsettings
        //config.AddStaticRoutesXmlConfiguration(); // Overriding settings with StaticRoutes.Xml 
        })
        .ConfigureLogging((context,logging) =>
        {
        logging.ClearProviders();
        var loggerConfig = AdsLoggerConfiguration.CreateFromEnvironment();
        logging.AddProvider(new AdsLoggerProvider(() => loggerConfig));

        // Adding console logging here.
        //var loggerConfig = AdsLoggerConfiguration.CreateFromConfiguration(context.Configuration);
        //logging.AddProvider(new AdsLoggerProvider(() => loggerConfig));

        // Too inefficient!
        //logging.AddProvider(new AdsLoggerProvider(() => AdsLoggerConfiguration.CreateFromEnvironment()));

        //logging.AddProvider(new AdsLoggerProvider(() => loggerConfig));
        logging.SetMinimumLevel(LogLevel.Debug);
        });
        return ret;
    }
}

/// <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 RouterService : BackgroundService
{
    private readonly ILoggerFactory _loggerFactory;

    /// <summary>
    /// Logger
    /// </summary>
    private readonly ILogger<RouterService> _logger;
    /// <summary>
    /// Configuration
    /// </summary>
    private readonly IConfiguration _configuration;

    /// <summary>
    /// Initializes a new instance of the <see cref="RouterService"/> class.
    /// </summary>
    /// <param name="loggerFactory">The logger factory.</param>
    /// <param name="configuration">The configuration.</param>
    public RouterService(IConfiguration configuration, ILoggerFactory loggerFactory)
    {
    _loggerFactory = loggerFactory;
    _logger = loggerFactory.CreateLogger<RouterService>();
    _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)
    {
    AmsTcpIpRouter router;

    using (_logger.BeginScope("Starting"))
    {
        StringBuilder appCommon = new StringBuilder();

        appCommon.AppendLine($"ApplicationPath: {Environment.GetCommandLineArgs()[0]}");
        appCommon.AppendLine($"BaseDirectory: {AppContext.BaseDirectory}");
        appCommon.AppendLine($"CurrentDirectory: {Directory.GetCurrentDirectory()}");
        //_logger.LogInformation(sB.ToString());

        StringBuilder config = new StringBuilder();
        string value = _configuration.GetValue("ASPNETCORE_ENVIRONMENT", "Production");
        config.AppendLine($"ASPNETCORE_ENVIRONMENT: {value}");

        Console.WriteLine("Application Directories");
        Console.WriteLine("=======================");
        Console.WriteLine(appCommon);
        Console.WriteLine("");
        Console.WriteLine("Configuration");
        Console.WriteLine("=============");
        Console.WriteLine(config);
        Console.WriteLine("");

        Console.WriteLine("Press Ctrl + C to shutdown!");

        router = new AmsTcpIpRouter(_configuration, _loggerFactory);
        router.RouterStatusChanged += Router_RouterStatusChanged;

        // Use this overload to instantiate a Router without support of IHost/IConfigurationProvider support and parametrize by code
        // AmsTcpIpRouter router = new AmsTcpIpRouter(new AmsNetId("1.2.3.4.5.6"), AmsTcpIpRouter.DEFAULT_TCP_PORT,IPAddress.Loopback,AmsTcpIpRouter.DEFAULT_TCP_PORT,_logger);
        // router.AddRoute(...);

        _logger.LogInformation(appCommon.ToString());
        _logger.LogInformation(config.ToString());
    }

    Task routerTask = router.StartAsync(cancel); // Start the router

    //#if ADSSERVER
    // AdsServer could be started here:
    SystemServiceServer systemService = new SystemServiceServer(router, _loggerFactory);
    AdsRouterServer adsRouterService = new AdsRouterServer(router, _loggerFactory);

    //TestAdsServer testServer = new TestAdsServer(_logger);
    //_logger.LogInformation($"Adding Test Server on port '{systemService.ServerAddress}'");
    Task systemServiceTask = systemService.ConnectServerAndWaitAsync(cancel);
    Task routerServerTask = adsRouterService.ConnectServerAndWaitAsync(cancel);

    await Task.WhenAll(routerTask, systemServiceTask, routerServerTask);

    //await routerTask;
    //#endif
    }

    /// <summary>
    /// Handles the RouterStatusChanged event of the <see cref="AmsTcpIpRouter"/>
    /// </summary>
    /// <param name="sender">The source of the event.</param>
    /// <param name="e">The <see cref="RouterStatusChangedEventArgs"/> instance containing the event data.</param>
    private void Router_RouterStatusChanged(object? sender, RouterStatusChangedEventArgs e)
    {
    if (e.RouterStatus == RouterStatus.Started)
    {
        // From here on, the Router is available to receive Data.
    }
    }
}

Reference

TwinCAT.Ads.TcpRouter Namespace RouteConfig AmsConfiguration

Beckhoff Automation GmbH & Co. KG 2001-2026