|
| 1 | +# Simulation Driver |
| 2 | + |
| 3 | +If none of the existing, commercial drivers from `Moryx.Drivers.Simulation` fits your requirements, you can easily implement your own driver. All you need to do is implement the interface `Moryx.Simulation.ISimulationDriver` as well as the interface of the driver you want to replace like `IMessageDriver<object>` or `IInOutDriver`. |
| 4 | + |
| 5 | +A module like the commercial simulator will call `Ready` and `Result` on your instance as a replacement for the events usually received from real drivers and sensors. You need to translate them into values or events of you driver interface like `IMessageDriver.Received`. The methods references the activity which you can use to extract the relevant attributes like process id, carrier or product identifiers as needed by your cell. Process execution initiated by the drivers API like parameter values or `Send` methods need to be represented by the `SimulatedState`. |
| 6 | + |
| 7 | +## Example of simulated driver |
| 8 | + |
| 9 | +So here is an example of how your mock driver can implement `Moryx.Simulation.ISimulationDriver`: |
| 10 | +``` csharp |
| 11 | + [ResourceRegistration] |
| 12 | + public class TestMockDriver : Driver, IMessageDriver<object>,ISimulationDriver { |
| 13 | + |
| 14 | + public bool HasChannels => false; |
| 15 | + |
| 16 | + public IDriver Driver => this; |
| 17 | + |
| 18 | + public string Identifier => Name; |
| 19 | + |
| 20 | + private SimulationState _simulatedState; |
| 21 | + // simulated state of the driver |
| 22 | + public SimulationState SimulatedState |
| 23 | + { |
| 24 | + get => _simulatedState; |
| 25 | + private set |
| 26 | + { |
| 27 | + _simulatedState = value; |
| 28 | + SimulatedStateChanged?.Invoke(this, value); |
| 29 | + } |
| 30 | + } |
| 31 | + |
| 32 | + // cell referenced by the driver |
| 33 | + [ResourceReference(ResourceRelationType.Driver, ResourceReferenceRole.Source)] |
| 34 | + public AssemblyCell Cell { get; set; } |
| 35 | + |
| 36 | + public IEnumerable<ICell> Usages => new[] { Cell }; |
| 37 | + |
| 38 | + protected override void OnStart() |
| 39 | + { |
| 40 | + base.OnStart(); |
| 41 | + // initial simulated state of the driver |
| 42 | + SimulatedState = SimulationState.Idle; |
| 43 | + } |
| 44 | + |
| 45 | + public IMessageChannel<TChannel> Channel<TChannel>(string identifier) |
| 46 | + { |
| 47 | + throw new NotImplementedException(); |
| 48 | + } |
| 49 | + |
| 50 | + public IMessageChannel<TSend, TReceive> Channel<TSend, TReceive>(string identifier) |
| 51 | + { |
| 52 | + throw new NotImplementedException(); |
| 53 | + } |
| 54 | + |
| 55 | + // Message received from the cell |
| 56 | + public void Send(object payload) |
| 57 | + { |
| 58 | + switch (payload) |
| 59 | + { |
| 60 | + case AssembleProductMessage assemble: |
| 61 | + SimulatedState = SimulationState.Executing; |
| 62 | + break; |
| 63 | + case ReleaseWorkpieceMessage release: |
| 64 | + SimulatedState = SimulationState.Idle; |
| 65 | + break; |
| 66 | + } |
| 67 | + } |
| 68 | + |
| 69 | + public Task SendAsync(object payload) |
| 70 | + { |
| 71 | + Send(payload); |
| 72 | + return Task.CompletedTask; |
| 73 | + } |
| 74 | + |
| 75 | + public void Ready(IActivity activity) |
| 76 | + { |
| 77 | + SimulatedState = SimulationState.Requested; |
| 78 | + |
| 79 | + Received?.Invoke(this, new WorkpieceArrivedMessage { ProcessId = activity.Process.Id }); |
| 80 | + } |
| 81 | + |
| 82 | + public void Result(SimulationResult result) |
| 83 | + { |
| 84 | + Received?.Invoke(this, new AssemblyCompletedMessage { Result = result.Result }); |
| 85 | + } |
| 86 | + |
| 87 | + public event EventHandler<object> Received; |
| 88 | + |
| 89 | + public event EventHandler<SimulationState> SimulatedStateChanged; |
| 90 | + |
| 91 | + //... rest of your codes// |
| 92 | + } |
| 93 | +``` |
| 94 | + |
| 95 | +Note: The `Send()` method might differ from cell to cell.You can override the `Send()` and do your implementation of what needs to happend when your "mock" driver receives something from the cell. In case your driver doesn't have a `send()` method, you can use your own method and react upon the type of message you received just like described inside the `TestMockDriver.Send()` method above. |
| 96 | + |
| 97 | + # How does my Cell use my `MockDriver` ? |
| 98 | + |
| 99 | +In your cell definition/Class you can use the following example based on the type of driver you're trying to simulate. Let's say we are trying to "mock" an `MQTT driver` since Moryx MQTT driver implements from `IMessageDriver<object>` in your cell you can have the following case: |
| 100 | +```csharp |
| 101 | + // SolderingCell.cs |
| 102 | + |
| 103 | + [ResourceRegistration] |
| 104 | + public class SolderingCell : Cell |
| 105 | + { |
| 106 | + //... rest of your codes// |
| 107 | +
|
| 108 | + [ResourceReference(ResourceRelationType.Driver, IsRequired = true)] |
| 109 | + public IMessageDriver<object> Driver { get; set; } |
| 110 | + |
| 111 | + //... rest of your codes// |
| 112 | + } |
| 113 | +``` |
| 114 | + |
| 115 | +Since the our "mock" driver has the following property defined: |
| 116 | +```csharp |
| 117 | + //... rest of the codes// |
| 118 | +
|
| 119 | + /// <summary> |
| 120 | + /// Cell linked to the driver |
| 121 | + /// </summary> |
| 122 | + [ResourceReference(ResourceRelationType.Driver, ResourceReferenceRole.Source)] |
| 123 | + public AssemblyCell Cell { get; set; } |
| 124 | + |
| 125 | + //... rest of the codes// |
| 126 | +``` |
| 127 | +Moryx will take care of the relationship once you assign the driver to the cell. |
| 128 | + To start the communication you can define message types in your resources folder. For starter we can define some message types. You can also use already existing messages |
| 129 | + ```csharp |
| 130 | + //AssembleProductMessage.cs |
| 131 | +
|
| 132 | + /// <summary> |
| 133 | + /// Message specificto start an activity |
| 134 | + /// </summary> |
| 135 | + public class AssembleProductMessage |
| 136 | + { |
| 137 | + public long ActivityId { get; set; } |
| 138 | + } |
| 139 | + |
| 140 | + //AssemblyCompletedMessage.cs |
| 141 | + public class AssemblyCompletedMessage |
| 142 | + { |
| 143 | + public int Result { get; set; } |
| 144 | + } |
| 145 | + |
| 146 | + //ReleaseWorkpieceMessage.cs |
| 147 | + public class ReleaseWorkpieceMessage |
| 148 | + { |
| 149 | + //rest of the code... |
| 150 | + } |
| 151 | + |
| 152 | + //WorkpieceArrivedMessage.cs |
| 153 | + public class WorkpieceArrivedMessage |
| 154 | + { |
| 155 | + public long ProcessId { get; set; } |
| 156 | + } |
| 157 | + ``` |
| 158 | + In the cell when you need to send a data to the driver you can do as described bellow: |
| 159 | + ```csharp |
| 160 | + //AssemblyCell.cs |
| 161 | + //... rest of the codes// |
| 162 | +
|
| 163 | + public override void StartActivity(ActivityStart activityStart) |
| 164 | + { |
| 165 | + Driver.Send(new AssembleProductMessage { ActivityId = activityStart.Activity.Id }); |
| 166 | + } |
| 167 | + |
| 168 | + //... rest of the codes// |
| 169 | + ``` |
| 170 | + As you can see inside the `StartActivity` method we want the cell to send data to the driver. |
| 171 | + |
| 172 | + Now in our driver `TestMockDriver` class above. Inside the `public void Send(object payload)` method we are filtering the payload based on the message type that we just define. We can act upon the type of message received. For instance: |
| 173 | + ```csharp |
| 174 | + //... rest of the codes// |
| 175 | +
|
| 176 | + public void Send(object payload) |
| 177 | + { |
| 178 | + switch (payload) |
| 179 | + { |
| 180 | + case AssembleProductMessage assemble: |
| 181 | + SimulatedState = SimulationState.Executing; |
| 182 | + break; |
| 183 | + case ReleaseWorkpieceMessage release: |
| 184 | + SimulatedState = SimulationState.Idle; |
| 185 | + break; |
| 186 | + } |
| 187 | + } |
| 188 | + |
| 189 | + //... rest of the codes// |
| 190 | + ``` |
0 commit comments