public async static Task Reset(this ITransceiver transceiver)
{
var message = new InterfaceControlMessage(InterfaceControlCommand.Reset);
await transceiver.Send(message);
await Task.Delay(50);
}
public DroneMessenger(
ITransceiver transceiver,
IReceiver stateReceiver,
IReceiver videoReceiver)
{
this.transceiver = transceiver ?? throw new ArgumentNullException(nameof(transceiver));
this.stateReceiver = stateReceiver ?? throw new ArgumentNullException(nameof(stateReceiver));
this.videoReceiver = videoReceiver ?? throw new ArgumentNullException(nameof(videoReceiver));
this.Controller = new FlightController(this.transceiver);
this.Controller.ConnectionStateChanged +=
(object sender, ConnectionStateChangedArgs e) =>
{
if (e.IsConnected)
{
this.StartLisenters();
}
else
{
this.StopListeners();
}
};
this.StateObserver = new StateObserver(this.stateReceiver);
this.StateObserver.StateChanged += this.Controller.UpdateState;
this.Controller.PositionChanged += this.StateObserver.UpdatePosition;
this.VideoObserver = new VideoObserver(this.videoReceiver);
}
/// <summary>
/// Creates a new session.
/// </summary>
/// <param name="owner">Owner end point.</param>
/// <param name="socket">Session socket.</param>
/// <param name="id">Session identifier.</param>
public ActiveSession(ActiveEndPoint <T> owner, Socket socket, int id)
{
Owner = owner;
Id = id;
Socket = socket;
Stream = new NetworkStreamEx(socket, Owner.Host.AuthenticationData);
Stream.Authenticate(); // TODO: make authentication optional for StartTLS support
if (typeof(T) == typeof(byte[]))
{
Transceiver = new BinaryTransceiver() as ITransceiver <T>;
}
else if (typeof(T) == typeof(BinaryPacket))
{
Transceiver = new FastBinaryTransceiver() as ITransceiver <T>;
}
else if (typeof(T) == typeof(X690.Message))
{
Transceiver = new X690Transceiver() as ITransceiver <T>;
}
else if (typeof(T) == typeof(string))
{
Transceiver = new StringTransceiver() as ITransceiver <T>;
}
else
{
throw new InvalidDataException("Unsupported message type.");
}
}
private static async Task SendMessage(ITransceiver transceiver, string input)
{
string data = null;
switch (CurrentService.Value)
{
case Service.Chat:
data = BuildChatRequest(input);
break;
case Service.Ping:
data = BuildPingRequest(input);
break;
case Service.Configure:
data = BuildConfigureRequest(input);
break;
case Service.File:
data = BuildFileRequest(input);
break;
}
if (!string.IsNullOrEmpty(data))
{
await transceiver.Transmit(data);
}
}
public JoyStickFlightTest(
IRepository repository,
ITransceiver transceiver,
IReceiver stateReceiver,
IReceiver videoReceiver)
{
this.tello = new DroneMessenger(transceiver, stateReceiver, videoReceiver);
this.repository = repository ?? throw new ArgumentNullException(nameof(repository));
this.tello.Controller.ConnectionStateChanged += this.Controller_ConnectionStateChanged;
this.tello.Controller.ExceptionThrown += this.Controller_ExceptionThrown;
this.tello.Controller.ResponseReceived += this.Controller_ResponseReceived;
this.tello.StateObserver.StateChanged += this.StateObserver_StateChanged;
this.tello.VideoObserver.VideoSampleReady += this.VideoObserver_VideoSampleReady;
this.repository.CreateCatalog <Session>();
this.repository.CreateCatalog <ObservationGroup>();
this.repository.CreateCatalog <StateObservation>();
this.repository.CreateCatalog <AirSpeedObservation>();
this.repository.CreateCatalog <AttitudeObservation>();
this.repository.CreateCatalog <BatteryObservation>();
this.repository.CreateCatalog <HobbsMeterObservation>();
this.repository.CreateCatalog <PositionObservation>();
this.repository.CreateCatalog <ResponseObservation>();
this.session = this.repository.NewEntity <Session>();
}
internal BufferedReadTransceiver(ITransceiver underlying, int bufferSize = 256)
{
Underlying = underlying;
// The _buffer data member holds the buffered data. There's no buffered data until we receive data
// from the underlying socket so the array segment point to an empty segment.
_buffer = new ArraySegment <byte>(new byte[bufferSize], 0, 0);
}
public MessageGovernor(ICache cache, ITransceiver transceiver, Options options)
{
_cache = cache;
_transceiver = transceiver;
_options = options;
Task.Run(() => tranceiveAsync());
}
private async Task <ILoraWanGateway> CreateGateway()
{
try
{
// Create the transceiver:
TransceiverPinSettings pinSettings = GetTransceiverPinSettings();
ITransceiver transceiver = await TransceiverFactory.Create(_gatewaySettings, pinSettings).ConfigureAwait(false);
transceiver.OnMessageReceived += TransceiverOnMessageReceived;
// Create the GPS manager (if existing):
IPositionProvider positionProvider;
if (UseGpsManager())
{
// Create the GPS manager:
IGpsManager gpsManager = await GpsManagerFactory.Create(GpsManagerSettings.Default).ConfigureAwait(false);
// Hook up the event fired when a new position is recorded:
gpsManager.OnPositionData += GpsManagerPositionDataAsync;
// Start the GPS:
await gpsManager.WakeUp().ConfigureAwait(false);
// Make the Gateway use the GpsManager as position provider
// (sending the actual coordinates in its status messages):
positionProvider = gpsManager;
}
else
{
// Make the Gateway use "no position" as its coordinate:
positionProvider = FixedPositionProvider.NoPositionProvider;
// ...or give it a fixed coordinate:
//positionProvider = new FixedPositionProvider(new SimplePosition(55.597382, 12.95889, 18.4));
}
// Get the gateway EUI:
GatewayEui gatewayEui = await GetGatewayEui().ConfigureAwait(false);
WriteLog("The gateway EUI: " + gatewayEui);
// Create the LoRa WAN gateway handler:
return(LoraWanGatewayFactory.Create(
transceiver,
_gatewaySettings,
gatewayEui,
positionProvider));
}
catch (Exception exception)
{
WriteLog("Failed creating the LoRaWAN gateway:\r\n" + exception.Message);
Debugger.Break();
return(null);
}
}
private void CompleteRequest(ITransceiver client, IRequest request, TimeSpan delay)
{
Task.Factory.StartNew(async() =>
{
await Task.Delay(delay);
var response = new Response(request, ProxySubject.EchoValueConst);
await client.ReceiveAsync(response);
});
}
protected IPConnection(
IConnectionManager manager,
Endpoint endpoint,
ITransceiver transceiver,
BinaryConnection connection,
IConnector?connector,
string connectionId,
ObjectAdapter?adapter)
: base(manager, endpoint, connection, connector, connectionId, adapter) => _transceiver = transceiver;
//
// Only for use by Connector, Acceptor
//
internal Transceiver(ITransceiver transceiver)
{
_transceiver = transceiver;
_configuration = Configuration.GetInstance();
_initialized = false;
_readBuffer = new byte[1024 * 8]; // 8KB buffer
_readBufferOffset = 0;
_readBufferPos = 0;
_buffered = _configuration.Buffered();
}
public ProxyFactory(
ITransceiverConnectionSettings connectionSettings,
ITransceiver client,
IAsyncCoupler <IMessage> asyncCoupler,
ILogger logger)
{
_connectionSettings = connectionSettings ?? throw new ArgumentNullException(nameof(connectionSettings));
_client = client ?? throw new ArgumentNullException(nameof(client));
_asyncCoupler = asyncCoupler ?? throw new ArgumentNullException(nameof(asyncCoupler));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public async static Task SetMode(this ITransceiver transceiver, TransceiverType transceiverType, params Protocol[] protocols)
{
var messages = Buffer.Empty(9);
messages[0] = transceiverType;
messages[2] = (byte)protocols.Where(protocol => protocol.MessageNumber == 3).Sum(protocol => protocol.Value);
messages[3] = (byte)protocols.Where(protocol => protocol.MessageNumber == 4).Sum(protocol => protocol.Value);
messages[4] = (byte)protocols.Where(protocol => protocol.MessageNumber == 5).Sum(protocol => protocol.Value);
await transceiver.Send(new InterfaceControlMessage(InterfaceControlCommand.SetMode, messages));
}
/// <summary>
/// Create an instance of <see cref="ILoraWanGateway"/>.
/// </summary>
/// <param name="transceiver">The transceiver.</param>
/// <param name="gatewaySettings">The gateway settings of <see cref="ILoraWanGateway"/>.</param>
/// <param name="gatewayEui">The unique Gateway EUI.</param>
/// <param name="positionProvider">Optional. Interface to a <see cref="IPositionProvider"/>.</param>
/// <returns></returns>
public static ILoraWanGateway Create(
ITransceiver transceiver,
LoraWanGatewaySettings gatewaySettings,
GatewayEui gatewayEui,
IPositionProvider positionProvider = null)
{
return(new LoraWanGateway(
transceiver,
gatewaySettings,
gatewayEui,
positionProvider ?? FixedPositionProvider.NoPositionProvider));
}
/// <summary>
/// Send a message with no timeout.
/// </summary>
private async Task SendMessage(ITransceiver loraTransceiver, byte[] message)
{
var stopwatch = new Stopwatch(); // Only out of pure interest...
stopwatch.Start();
bool successfullySent = await loraTransceiver.Transmit(message).ConfigureAwait(false);
stopwatch.Stop();
WriteLog(successfullySent
? $"Successfully sent in {stopwatch.ElapsedMilliseconds} milliseconds."
: $"Failed after {stopwatch.ElapsedMilliseconds} milliseconds.");
}
public async ValueTask <Connection> AcceptAsync()
{
Socket fd = await _socket.AcceptAsync().ConfigureAwait(false);
ITransceiver transceiver = ((TcpEndpoint)Endpoint).CreateTransceiver(fd, _adapter.Name);
MultiStreamTransceiverWithUnderlyingTransceiver multiStreamTranceiver = Endpoint.Protocol switch
{
Protocol.Ice1 => new LegacyTransceiver(transceiver, Endpoint, _adapter),
_ => new SlicTransceiver(transceiver, Endpoint, _adapter)
};
return(((TcpEndpoint)Endpoint).CreateConnection(_manager, multiStreamTranceiver, null, "", _adapter));
}
public override Connection CreateConnection(
IConnectionManager manager,
ITransceiver transceiver,
IConnector?connector,
string connectionId,
ObjectAdapter?adapter) =>
new WSConnection(manager,
this,
transceiver,
Protocol == Protocol.Ice1 ?
(BinaryConnection) new Ice1BinaryConnection(transceiver, this, adapter) :
new SlicBinaryConnection(transceiver, this, adapter),
connector,
connectionId,
adapter);
/// <summary>
/// Send a message with a timeout.
/// </summary>
private async Task SendMessage(ITransceiver loraTransceiver, byte[] message, TimeSpan timeout)
{
using (var cancellationTokenSource = new CancellationTokenSource(timeout))
{
var stopwatch = new Stopwatch(); // Only out of pure interest...
stopwatch.Start();
bool successfullySent = await loraTransceiver.Transmit(message, cancellationTokenSource.Token).ConfigureAwait(false);
stopwatch.Stop();
WriteLog(successfullySent
? $"Successfully sent in {stopwatch.ElapsedMilliseconds} milliseconds."
: $"Failed after {stopwatch.ElapsedMilliseconds} milliseconds.");
}
}
private async Task <bool> InitLoraTransceiver()
{
try
{
_transceiver = await TransceiverFactory.Create(GetRadioSettings(), GetPinSettings()).ConfigureAwait(false);
_transceiver.OnMessageReceived += TransceiverOnMessageReceived;
return(true);
}
catch (Exception exception)
{
WriteLog("Failed initiating the LoRa transceiver:\r\n" + exception.Message);
return(false);
}
}
public Connection Connect(string connectionId)
{
ITransceiver transceiver = _endpoint.CreateTransceiver(this, _addr, _proxy);
MultiStreamTransceiverWithUnderlyingTransceiver multiStreamTranceiver = _endpoint.Protocol switch
{
Protocol.Ice1 => new LegacyTransceiver(transceiver, _endpoint, null),
_ => new SlicTransceiver(transceiver, _endpoint, null)
};
return(_endpoint.CreateConnection(_endpoint.Communicator.OutgoingConnectionFactory,
multiStreamTranceiver,
this,
connectionId,
null));
}
// Only for use by TcpEndpoint.
internal SslTransceiver(Communicator communicator, ITransceiver del, string hostOrAdapterName, bool incoming)
{
_communicator = communicator;
_engine = communicator.SslEngine;
_delegate = del;
_incoming = incoming;
if (_incoming)
{
_adapterName = hostOrAdapterName;
}
else
{
_host = hostOrAdapterName;
}
SslStream = null;
}
// Only for use by ConnectorI, AcceptorI.
internal SslTransceiver(Communicator communicator, ITransceiver del, string hostOrAdapterName, bool incoming)
{
_communicator = communicator;
_engine = communicator.SslEngine;
_delegate = del;
_incoming = incoming;
if (_incoming)
{
_adapterName = hostOrAdapterName;
}
else
{
_host = hostOrAdapterName;
}
SslStream = null;
_verifyPeer = _communicator.GetPropertyAsInt("IceSSL.VerifyPeer") ?? 2;
}
// Only for use by TcpEndpoint.
internal SslTransceiver(
Communicator communicator,
ITransceiver underlying,
string hostOrAdapterName,
bool incoming)
{
_communicator = communicator;
_engine = communicator.SslEngine;
_underlying = underlying;
_incoming = incoming;
if (_incoming)
{
_adapterName = hostOrAdapterName;
}
else
{
_host = hostOrAdapterName;
}
}
public MainViewModel(
IUIDispatcher dispatcher,
IUINotifier notifier,
IRepository repository,
ITransceiver transceiver,
IReceiver stateReceiver,
IReceiver videoReceiver)
: base(dispatcher, notifier)
{
this.tello = new DroneMessenger(transceiver, stateReceiver, videoReceiver);
repository.CreateCatalog <Session>();
repository.CreateCatalog <ObservationGroup>();
repository.CreateCatalog <StateObservation>();
repository.CreateCatalog <AirSpeedObservation>();
repository.CreateCatalog <AttitudeObservation>();
repository.CreateCatalog <BatteryObservation>();
repository.CreateCatalog <HobbsMeterObservation>();
repository.CreateCatalog <PositionObservation>();
repository.CreateCatalog <ResponseObservation>();
var session = repository.NewEntity <Session>();
this.StateViewModel = new TelloStateViewModel(
dispatcher,
notifier,
this.tello.StateObserver,
repository,
session);
this.VideoViewModel = new TelloVideoViewModel(
dispatcher,
notifier,
this.tello.VideoObserver);
this.ControllerViewModel = new TelloControllerViewModel(
dispatcher,
notifier,
this.tello.Controller,
repository,
session);
}
internal static TProxyInterface Create <TProxyInterface>(
ITransceiverConnectionSettings connectionSettings,
ITransceiver client,
IAsyncCoupler <IMessage> asyncCoupler,
ILogger logger,
IProxySettings proxySettings) where TProxyInterface : class
{
var result = Create <TProxyInterface, Proxy>();
var proxy = (result as Proxy);
proxy._connectionSettings = connectionSettings ?? throw new ArgumentNullException(nameof(connectionSettings));
proxy._client = client ?? throw new ArgumentNullException(nameof(client));
proxy._asyncCoupler = asyncCoupler ?? throw new ArgumentNullException(nameof(asyncCoupler));
proxy._logger = logger ?? throw new ArgumentNullException(nameof(logger));
proxy._proxySettings = proxySettings ?? throw new ArgumentNullException(nameof(proxySettings));
if (string.IsNullOrEmpty(proxySettings.OrganizationId))
{
throw new ArgumentNullException(nameof(proxySettings.OrganizationId));
}
if (string.IsNullOrEmpty(proxySettings.InstanceId))
{
throw new ArgumentNullException(nameof(proxySettings.InstanceId));
}
if (string.IsNullOrEmpty(connectionSettings.RpcClientReceiver.ResourceName))
{
throw new ArgumentNullException(nameof(connectionSettings.RpcClientReceiver.ResourceName));
}
proxy._replyPath = connectionSettings.RpcClientReceiver.ResourceName;
if (connectionSettings.RpcClientTransmitter.TimeoutInSeconds == 0)
{
throw new ArgumentException("timeout must be greater than zero", nameof(connectionSettings.RpcClientReceiver.TimeoutInSeconds));
}
proxy._requestTimeout = TimeSpan.FromSeconds(connectionSettings.RpcClientTransmitter.TimeoutInSeconds);
return(result);
}
private Connection CreateConnection(ITransceiver transceiver, ConnectorInfo ci)
{
lock (this)
{
Debug.Assert(_pending.ContainsKey(ci.Connector) && transceiver != null);
//
// Create and add the connection to the connection map. Adding the connection to the map
// is necessary to support the interruption of the connection initialization and validation
// in case the communicator is destroyed.
//
Connection connection;
try
{
if (_destroyed)
{
throw new CommunicatorDestroyedException();
}
connection = new Connection(_communicator, _monitor, transceiver, ci.Connector,
ci.Endpoint.NewCompressionFlag(false), null);
}
catch (System.Exception)
{
try
{
transceiver.Close();
}
catch (System.Exception)
{
// Ignore
}
throw;
}
_connections.Add(ci.Connector, connection);
_connectionsByEndpoint.Add(connection.Endpoint, connection);
_connectionsByEndpoint.Add(connection.Endpoint.NewCompressionFlag(true), connection);
return(connection);
}
}
public LoraWanGateway(
ITransceiver transceiver,
LoraWanGatewaySettings gatewaySettings,
GatewayEui gatewayEui,
IPositionProvider positionProvider)
{
_stopwatch.Start();
_transceiver = transceiver;
_gatewaySettings = gatewaySettings;
_positionProvider = positionProvider;
_loraNetworkClients = gatewaySettings.Hosts
.Select(x => new LoraNetworkClient(new HostName(x), 1700))
.ToArray();
_messageComposer = new MessageComposer(gatewayEui);
_transceiver.OnMessageReceived += TransceiverOnMessageReceived;
_datr = GetSF() + GetBW();
_codr = GetCodr();
}
// Only for use by TcpEndpoint.
internal SslTransceiver(
Communicator communicator,
ITransceiver underlying,
string hostOrAdapterName,
bool incoming,
IConnector?connector = null)
{
Debug.Assert(incoming || connector != null);
_communicator = communicator;
_connector = connector;
_engine = communicator.SslEngine;
_underlying = underlying;
_incoming = incoming;
if (_incoming)
{
_adapterName = hostOrAdapterName;
}
else
{
_host = hostOrAdapterName;
}
}
public Channel(uint periodicNumber, ITransceiver transceiver)
{
PeriodicNumber = periodicNumber;
_transceiver = transceiver;
}
public void Register(ITransceiver transceiver)
{
transceiver.SendMessage = BroadcastMessage;
_transceivers.Add(transceiver);
}
