public async Task StopAsync()
        {
            lock (_msgSendTimers)
            {
                if (Status != null && !Status.IsRunning)
                {
                    return;
                }


                foreach (var tmr in _msgSendTimers)
                {
                    tmr.Change(Timeout.Infinite, Timeout.Infinite);
                    tmr.Dispose();
                }

                _msgSendTimers.Clear();

                _receiveTaskCancelTokenSource?.Cancel();
                _receiveTaskCancelTokenSource = null;
            }

            switch (_simulator.DefaultTransport.Value)
            {
            case TransportTypes.MQTT:
                DisconnectMQTT();
                break;

            case TransportTypes.AzureIoTHub:
                await DisconnectAzureIoTHubAsync();

                break;

            case TransportTypes.TCP:
                _tcpClient?.DisconnectAsync();
                _tcpClient.Dispose();
                _tcpClient = null;
                break;

            case TransportTypes.UDP:
                await _udpClient?.DisconnectAsync();

                _udpClient.Dispose();
                _udpClient = null;
                break;
            }


            Status = new SimulatorStatus()
            {
                IsRunning = false,
                Text      = "Stopped"
            };

            await _notificationPublisher.PublishAsync(Targets.WebSocket, Channels.Simulator, InstanceId, $"Simulator Stopped", CurrentState);

            await _notificationPublisher.PublishAsync(Targets.WebSocket, Channels.Simulator, InstanceId, $"Status Update", Status);
        }
        public async Task StartAsync()
        {
            lock (_msgSendTimers)
            {
                if (Status != null && Status.IsRunning)
                {
                    return;
                }
            }

            await ConnectAsync();

            var messages = new List <string>();

            lock (_msgSendTimers)
            {
                var transmisssionPlans = _instance.TransmissionPlans.Where(st => st?.ForState.Id == CurrentState.Id);
                if (transmisssionPlans.Any())
                {
                    foreach (var plan in transmisssionPlans)
                    {
                        plan.Message.Value = _simulator.MessageTemplates.Where(msg => msg.Id == plan.Message.Id).FirstOrDefault();

                        if (plan.Message.Value == null)
                        {
                            _adminLogger.AddError("SimulatorRuntime_Start", $"Could not resolve message template {plan.Message.Text}", _simulator.Name.ToKVP("simulatorName"));
                            messages.Add($"Could not resolve message template for {plan.Message.Text}");
                        }
                        else
                        {
                            var tmr = new Timer(SendMessage, plan, plan.PeriodMS, plan.PeriodMS);
                            messages.Add($"Started {plan.PeriodMS}ms timer for plan {plan.Message}");
                            _msgSendTimers.Add(tmr);
                        }
                    }
                }
                else
                {
                    messages.Add($"No transmission plans identified for state {CurrentState.Name} on {_simulator.Name}.");
                }
            }

            Status = new SimulatorStatus()
            {
                IsRunning = true,
                Text      = "Running"
            };

            foreach (var message in messages)
            {
                await _notificationPublisher.PublishAsync(Targets.WebSocket, Channels.Simulator, InstanceId, message, CurrentState);
            }

            await _notificationPublisher.PublishAsync(Targets.WebSocket, Channels.Simulator, InstanceId, $"Simulator Started", CurrentState);

            await _notificationPublisher.PublishAsync(Targets.WebSocket, Channels.Simulator, InstanceId, $"Status Update", Status);
        }