Skip to main content

ActorConfig

Configuration object passed to actors during construction, containing all necessary factories and services for actor operation.

Namespace: ControlBee.Models

Overview​

ActorConfig is the dependency injection container for actors. When creating an actor, the framework passes an ActorConfig instance that provides access to:

  • Device Factories - Create hardware interfaces (axes, I/O, vision, etc.)
  • System Services - Access to variable manager, event manager, time manager
  • Configuration - System properties and settings
  • UI Integration - Optional reference to UI actor

This design enables:

  • Testability (factories can be swapped with mocks)
  • Hardware independence (same actor code works with different hardware)
  • Service discovery (actors can access system services)
  • Dependency injection (all dependencies provided at construction time)

Constructor​

public ActorConfig(
    string actorName,
    ISystemConfigurations systemConfigurations,
    IAxisFactory axisFactory,
    IDigitalInputFactory digitalInputFactory,
    IDigitalOutputFactory digitalOutputFactory,
    IAnalogInputFactory analogInputFactory,
    IAnalogOutputFactory analogOutputFactory,
    IDialogFactory dialogFactory,
    IInitializeSequenceFactory initializeSequenceFactory,
    IBinaryActuatorFactory binaryActuatorFactory,
    IVisionFactory visionFactory,
    IVariableManager variableManager,
    IEventManager eventManager,
    ITimeManager timeManager,
    IScenarioFlowTester scenarioFlowTester,
    ISystemPropertiesDataSource systemPropertiesDataSource,
    IDeviceManager deviceManager,
    IActor? uiActor
)

Note: Typically created by the framework, not by user code.

Properties​

ActorName​

public string ActorName { get; }

The name assigned to this actor instance.

Usage Example:

public MyActor(ActorConfig config) : base(config)
{
    Logger.Info($"Creating actor: {config.ActorName}");
}

Device Factories​

AxisFactory​

public IAxisFactory AxisFactory { get; }

Factory for creating motion axis devices.

Usage Example:

public MyActor(ActorConfig config) : base(config)
{
    X = config.AxisFactory.Create();
    Y = config.AxisFactory.Create();
    Z = config.AxisFactory.Create();
}

DigitalInputFactory​

public IDigitalInputFactory DigitalInputFactory { get; }

Factory for creating digital input devices.

Usage Example:

MaterialSensor = config.DigitalInputFactory.Create();
SafetyGate = config.DigitalInputFactory.Create();

DigitalOutputFactory​

public IDigitalOutputFactory DigitalOutputFactory { get; }

Factory for creating digital output devices.

Usage Example:

Vacuum = config.DigitalOutputFactory.Create();
Cylinder = config.DigitalOutputFactory.Create();
StatusLight = config.DigitalOutputFactory.Create();

AnalogInputFactory​

public IAnalogInputFactory AnalogInputFactory { get; }

Factory for creating analog input devices.

Usage Example:

PressureSensor = config.AnalogInputFactory.Create();
TemperatureSensor = config.AnalogInputFactory.Create();

AnalogOutputFactory​

public IAnalogOutputFactory AnalogOutputFactory { get; }

Factory for creating analog output devices.

Usage Example:

ValveControl = config.AnalogOutputFactory.Create();
HeaterControl = config.AnalogOutputFactory.Create();

BinaryActuatorFactory​

public IBinaryActuatorFactory BinaryActuatorFactory { get; }

Factory for creating binary actuator devices (cylinders with position feedback).

Usage Example:

PickCylinder = config.BinaryActuatorFactory.Create();
ClampCylinder = config.BinaryActuatorFactory.Create();

VisionFactory​

public IVisionFactory VisionFactory { get; }

Factory for creating vision system devices.

Usage Example:

Camera = config.VisionFactory.Create();

DialogFactory​

public IDialogFactory DialogFactory { get; }

Factory for creating user dialog interfaces.

Usage Example:

ErrorDialog = config.DialogFactory.Create();
ConfirmDialog = config.DialogFactory.Create();

InitializeSequenceFactory​

public IInitializeSequenceFactory InitializeSequenceFactory { get; }

Factory for creating initialization sequences.

System Services​

VariableManager​

public IVariableManager VariableManager { get; }

Service for managing actor variables across the system.

Usage Example:

// Save all variables
config.VariableManager.Save();

// Load recipe
config.VariableManager.Load("Recipe1");

EventManager​

public IEventManager EventManager { get; }

Service for logging events to the database.

Usage Example:

config.EventManager.WriteEvent(
    severity: EventSeverity.Warning,
    category: "Motion",
    message: "Axis timeout",
    data: new { AxisName = "X", Timeout = 5000 }
);

TimeManager​

public ITimeManager TimeManager { get; }

Service for time management and stopwatch creation.

Usage Example:

var stopwatch = config.TimeManager.StartNew();
// ... operation ...
var elapsed = stopwatch.ElapsedMilliseconds;

DeviceManager​

public IDeviceManager DeviceManager { get; }

Service for managing all hardware devices.

Usage Example:

// Get all motion devices
var motionDevices = config.DeviceManager.GetDevicesByType<IMotionDevice>();

// Check for device errors
foreach (var device in motionDevices)
{
    if (device.Error)
    {
        HandleDeviceError(device);
    }
}

SystemPropertiesDataSource​

public ISystemPropertiesDataSource SystemPropertiesDataSource { get; }

Data source for system property values.

ScenarioFlowTester​

public IScenarioFlowTester ScenarioFlowTester { get; }

Service for scenario testing and simulation.

Configuration​

SystemConfigurations​

public ISystemConfigurations SystemConfigurations { get; }

System-wide configuration settings.

Usage Example:

if (config.SystemConfigurations.FakeMode)
{
    Logger.Info("Running in simulation mode");
}

var recipeName = config.SystemConfigurations.RecipeName;

UI Integration​

UiActor​

public IActor? UiActor { get; }

Optional reference to the UI actor for sending UI messages.

Usage Example:

// Send message to UI
if (config.UiActor != null)
{
    config.UiActor.Send(new Message(this, "UpdateDisplay", displayData));
}

Usage Example​

Basic Actor with Devices​

public class StageActor : Actor
{
    // Devices
    public IAxis X, Y, Z;
    public IDigitalOutput Vacuum;
    public IDigitalInput MaterialSensor;

    // Variables
    public Variable<Position3D> LoadPos = new(VariableScope.Local);
    public Variable<double> Speed = new(VariableScope.Local, 100.0);

    public StageActor(ActorConfig config) : base(config)
    {
        // Create devices using factories
        X = config.AxisFactory.Create();
        Y = config.AxisFactory.Create();
        Z = config.AxisFactory.Create();
        Vacuum = config.DigitalOutputFactory.Create();
        MaterialSensor = config.DigitalInputFactory.Create();

        // Map position to axes
        PositionAxesMap.Add(LoadPos, [X, Y, Z]);
    }

    public override void Start()
    {
        base.Start();
        SetState(new IdleState(this));
    }
}

Using System Services​

public class MonitorActor : Actor
{
    private readonly IEventManager eventManager;
    private readonly ITimeManager timeManager;

    public MonitorActor(ActorConfig config) : base(config)
    {
        eventManager = config.EventManager;
        timeManager = config.TimeManager;
    }

    public void LogOperationTime(string operationName, Action operation)
    {
        var stopwatch = timeManager.StartNew();

        try
        {
            operation();

            eventManager.WriteEvent(
                EventSeverity.Info,
                "Performance",
                $"{operationName} completed",
                new { Duration = stopwatch.ElapsedMilliseconds }
            );
        }
        catch (Exception ex)
        {
            eventManager.WriteEvent(
                EventSeverity.Error,
                "Error",
                $"{operationName} failed: {ex.Message}"
            );
        }
    }
}

Accessing Configuration​

public class ConfigurableActor : Actor
{
    public ConfigurableActor(ActorConfig config) : base(config)
    {
        // Adjust behavior based on system configuration
        if (config.SystemConfigurations.FakeMode)
        {
            Logger.Info($"{config.ActorName}: Running in simulation mode");
            // Use simulated devices or skip hardware operations
        }
        else
        {
            Logger.Info($"{config.ActorName}: Running in production mode");
            // Use real hardware
        }
    }
}

Testing Support​

ActorConfig enables easy testing by allowing factories to be replaced with mocks:

// Create test config with mock factories
var testConfig = new ActorConfig(
    actorName: "TestActor",
    systemConfigurations: mockSystemConfigurations,
    axisFactory: mockAxisFactory,
    digitalInputFactory: mockDigitalInputFactory,
    // ... other dependencies ...
);

// Create actor with test config
var actor = new MyActor(testConfig);

// Verify actor behavior with mocked dependencies
actor.Start();
// ... assertions ...

See Also​