AdsServer Class

Inheritance Hierarchy

SystemObject
  TwinCAT.Ads.ServerAdsServer
    TwinCAT.Ads.ServerAdsSymbolicServer

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

C#

public abstract class AdsServer : IDisposable

The AdsServer type exposes the following members.

Properties

Methods

Events

Fields

Remarks

Derived classes should overwrite the AMS indication methods to react on incoming requests. AMS The confirmation methods should be overwritten to receive replies on asynchronous requests sent by this ADS server.
Important note: Please contact Beckhoff to receive a reserved ADS port number if implementing your own customized AdsServer.

Example

The following sample shows how to derive from the AdsServer class and create your own Customized ADS Server.

C#

class Program
{
    public static void Main(string[] args)
    {
    CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureServices((hostContext, services) =>
        {
        services.AddHostedService<ServerWorker>();
        });
}

C#

public class ServerWorker : BackgroundService
{
    private readonly ILogger<ServerWorker> _logger;

    public ServerWorker(ILogger<ServerWorker> logger)
    {
    _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken cancel)
    {
    // Instantiate the server
    AdsSampleServer server = new AdsSampleServer(_logger);
    // Connect the server and wait for cancel
    await server.ConnectServerAndWaitAsync(cancel); 
    }
}

C#

/*
 * Extend the AdsServer class to implement your own ADS server.
 */
public class AdsSampleServer : AdsServer
{
    /// <summary>
    /// Fixed ADS Port (to be changed ...)
    /// </summary>
    const ushort ADS_PORT = 42;

    /// <summary>
    /// Fixed Name for the ADS Port (change this ...)
    /// </summary>
    const string ADS_PORT_NAME = "AdsSampleServer_Port42";

    /// <summary>
    /// Some simple data / ProcessImage
    /// </summary>
    private byte[] _dataBuffer = {1, 2, 3, 4};

    /// <summary>
    /// Ads State
    /// </summary>
    private AdsState _adsState = AdsState.Config;
    /// <summary>
    /// Device State
    /// </summary>
    private ushort _deviceState = 0;

    /// <summary>
    /// Notification dictionary, thread safe
    /// </summary>
    private ConcurrentDictionary<uint, NotificationRequestEntry> _notificationTable = new ConcurrentDictionary<uint, NotificationRequestEntry>();

    /// <summary>
    /// Simple counter for different Notification handles here.
    /// </summary>
    private uint _currentNotificationHandle = 0;

    /// <summary>
    /// Logger
    /// </summary>
    private ILogger _logger;

    /* Instantiate an ADS server with a fix ADS port assigned by the ADS router.
    */

    public AdsSampleServer()
    : this(null)
    {
    }

    public AdsSampleServer(ILogger logger) : base(ADS_PORT, ADS_PORT_NAME)
    {
    base.serverVersion = new Version(0, 0, 1);
    _logger = logger;
    }

    /* Overwrite the indication handlers of the AdsServer class for the services your ADS server
     * provides. They are called upon incoming requests. Indications that are not overwritten in
     * this class return the ADS DeviceServiceNotSupported error code to the requester.
     */

    /* Handler function for Write Indication */
    protected override Task<ResultWrite> OnWriteAsync(AmsAddress target, uint invokeId, uint indexGroup, uint indexOffset, ReadOnlyMemory<byte> writeData, CancellationToken cancel)
    {
    ResultWrite result;

    switch (indexGroup)     /* use index group (and offset) to distinguish between the services
                of this server */
    {
        case 0x10000:
        if (writeData.Length == 4)
        {
            writeData.CopyTo(_dataBuffer);
            result = ResultWrite.CreateSuccess();
        }
        else
        {
            result = ResultWrite.CreateError(AdsErrorCode.DeviceInvalidSize);
        }
        break;

        case 0x20000: /* used for the PLC Sample */
        if (writeData.Length == 4)
        {
            uint value = BinaryPrimitives.ReadUInt32LittleEndian(writeData.Span);
            result = ResultWrite.CreateSuccess();
        }
        else
        {
            result = ResultWrite.CreateError(AdsErrorCode.DeviceInvalidSize);
        }

        break;

        default: /* other services are not supported */
        result = ResultWrite.CreateError(AdsErrorCode.DeviceServiceNotSupported);
        break;
    }
    return Task.FromResult(result);
    }

    /* Handler function for Read Indication */
    protected override Task<ResultReadBytes> OnReadAsync(AmsAddress target, uint invokeId, uint indexGroup, uint indexOffset, int readLength, CancellationToken cancel)
    {
    ResultReadBytes result;

    /* Distinguish between services like in OnWriteAsync */
    result = ResultReadBytes.CreateSuccess(_dataBuffer.AsMemory());

    // or Error with ErrorCode
    // result = ResultReadBytes.CreateError(AdsErrorCode.DeviceNotSupported);
    return Task.FromResult(result);
    }

    /* Handler function for ReadWrite Indication */
    protected override Task<ResultReadWriteBytes> OnReadWriteAsync(AmsAddress target, uint invokeId, uint indexGroup, uint indexOffset, int readLength, ReadOnlyMemory<byte> writeData, CancellationToken cancel)
    {
    ResultReadWriteBytes result;

    /* Distinguish between services like in AdsWriteInd */

    if (readLength == 4 && writeData.Length == 4)
    {
        result = ResultReadWriteBytes.CreateSuccess(_dataBuffer.AsMemory(0, 4));
    }
    else
    {
        result = ResultReadWriteBytes.CreateError(AdsErrorCode.DeviceInvalidSize);
    }

    return Task.FromResult(result);
    }

    /* Handler function for ReadDeviceState Indication */
    protected override Task<ResultReadDeviceState> OnReadDeviceStateAsync(AmsAddress target, uint invokeId, CancellationToken cancel)
    {
    StateInfo state = new StateInfo(_adsState, _deviceState);
    ResultReadDeviceState result = ResultReadDeviceState.CreateSuccess(state);
    return Task.FromResult(result);
    }

    /* Handler function for WriteControl Indication */
    protected override Task<ResultAds> OnWriteControlAsync(AmsAddress target, uint invokeId, AdsState adsState, ushort deviceState, ReadOnlyMemory<byte> data, CancellationToken cancel)
    {
    // Set requested ADS and device status

    _adsState = adsState;
    _deviceState = deviceState;

    ResultAds result = ResultAds.CreateSuccess();
    return Task.FromResult(result);
    }

    /* Handler function for AddDeviceNotification Indication */
    protected override Task<ResultHandle> OnAddDeviceNotificationAsync(AmsAddress target, uint invokeId, uint indexGroup, uint indexOffset, int dataLength, AmsAddress receiver, NotificationSettings settings, CancellationToken cancel)
    {
    /* Create a new notification entry an store it in the notification table */
    NotificationRequestEntry notEntry = new NotificationRequestEntry(receiver, indexGroup, indexOffset, dataLength, settings);

    _notificationTable.AddOrUpdate(_currentNotificationHandle, notEntry, (key, value) => notEntry);
    ResultHandle result = ResultHandle.CreateSuccess(_currentNotificationHandle);

    _currentNotificationHandle++;
    return Task.FromResult(result);

    }

    /* Handler function for DeleteDeviceNotification Indication */
    protected override Task<ResultAds> OnDeleteDeviceNotificationAsync(AmsAddress target, uint invokeId, uint hNotification, CancellationToken cancel)
    {
    ResultAds result;

    /* check if the requested notification handle is still in the notification table */
    if (_notificationTable.ContainsKey(hNotification))
    {
        NotificationRequestEntry entry = null;
        _notificationTable.TryRemove(hNotification, out entry);
        result = ResultAds.CreateSuccess();
    }
    else // notification handle is not in the notification table -> return an error code
        // to the requester
    {
        result =  ResultAds.CreateError(AdsErrorCode.DeviceNotifyHandleInvalid);
    }

    return Task.FromResult(result);
    }

    /* Handler function for DeviceNotification Indication */
    protected override Task<ResultAds> OnDeviceNotificationAsync(AmsAddress sender, NotificationSamplesStamp[] stampHeaders, CancellationToken cancel)
    {
    /*
     * Call notification handlers.
     */
    return Task.FromResult(ResultAds.CreateSuccess());
    }
}

/// <summary>
/// AdsSampleServer Notification request entry
/// </summary>
internal class NotificationRequestEntry
{
    private AmsAddress _sender;     // the AmsNetId of the requester
    private uint _indexGroup;       // the requested index group
    private uint _indexOffset;      // the requested index offset
    private int _length;        // the number of bytes to send
    NotificationSettings _settings; // the notification settings

    internal NotificationRequestEntry(AmsAddress sender,
                      uint indexGroup,
                      uint indexOffset,
                      int dataLength,
                      NotificationSettings settings)
    {
    _sender = sender;
    _indexGroup = indexGroup;
    _indexOffset = indexOffset;
    _length = dataLength;
    _settings = settings;
    }
}

Reference

TwinCAT.Ads.Server Namespace

Beckhoff Automation GmbH & Co. KG 2001-2026