private void OnNewDataAvailable(byte[] frame)
{
ArrayList data = new ArrayList(frame);
do
{
try
{
SPPMessage msg = SPPMessage.DecodeMessage(data.OfType <byte>().ToArray());
MessageReceived?.Invoke(this, msg);
if (msg.TotalPacketSize >= data.Count)
{
break;
}
data.RemoveRange(0, msg.TotalPacketSize);
}
catch (InvalidDataException e)
{
InvalidDataException?.Invoke(this, e);
}
} while (data.Count > 0);
NewDataAvailable?.Invoke(this, frame);
}
public AASService()
{
Program.NewDataAvailable += (s, a) =>
{
NewDataAvailable?.Invoke(s, a);
};
}
public AASService()
{
Program.NewDataAvailable += (s, a) =>
{
NewDataAvailable?.Invoke(this, EventArgs.Empty);
};
}
public AASService()
{
// buildTree();
// NewDataAvailable?.Invoke(this, EventArgs.Empty);
Program.NewDataAvailable += (s, a) =>
{
// buildTree();
NewDataAvailable?.Invoke(this, a);
};
}
public void GetData()
{
if (!disposing && !TaskRunning)
{
TaskRunning = true;
float tmpdata;
tmpdata = DataHandler();
DateTime tmptime = DateTime.Now;
CurrentValue = new TimeDataPair(tmptime, tmpdata);
if (tm.Interval != CurrentInterval)
{
tm.Interval = CurrentInterval;
}
TaskRunning = false;
NewDataAvailable?.Invoke();
}
}
/// <summary>
/// Handler that is called everytime UART (Serial) data is received
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Port_DataReceived_Handler(object sender, SerialDataReceivedEventArgs e)
{
// If we did not receive the ACK bytes YET --> check if got them now
if (!IsConnected)
{
HandleACK();
}
// Read out RAW motion Data
var data = new byte[12];
BlockingRead(data, 0, 12);
// Convert to actual values
Axis_X = BitConverter.ToInt32(data, 0);
Axis_Y = BitConverter.ToInt32(data, 4);
Axis_Z = BitConverter.ToInt32(data, 8);
// Inform User that Data is now available
NewDataAvailable?.Invoke(this, EventArgs.Empty);
}
private async void BluetoothServiceLoop()
{
while (true)
{
try
{
_loopCancellation.Token.ThrowIfCancellationRequested();
Task.Delay(100).Wait(_loopCancellation.Token);
}
catch (OperationCanceledException)
{
IsStreamConnected = false;
Log.Debug("WindowsRT.BluetoothService: BluetoothServiceLoop cancelled.");
return;
}
try
{
Stream?incoming = null;
if (_socket == null)
{
Log.Error($"WindowsRT.BluetoothService: StreamSocket is null");
BluetoothErrorAsync?.Invoke(this,
new BluetoothException(BluetoothException.ErrorCodes.ReceiveFailed,
"Cannot retrieve incoming data stream. Device probably disconnected."));
await DisconnectAsync();
return;
}
lock (_socket)
{
incoming = _socket?.InputStream.AsStreamForRead();
}
if (incoming == null)
{
Log.Error($"WindowsRT.BluetoothService: Cannot retrieve incoming data stream");
BluetoothErrorAsync?.Invoke(this,
new BluetoothException(BluetoothException.ErrorCodes.ReceiveFailed,
"Cannot retrieve incoming data stream. Device probably disconnected."));
await DisconnectAsync();
return;
}
byte[] buffer = new byte[10000];
var b = incoming.Read(buffer, 0, buffer.Length);
if (b == 0)
{
// EOS
Log.Warning("WindowsRT.BluetoothService: End of stream. Connection closed by remote host");
break;
}
buffer = buffer.ShrinkTo(b);
NewDataAvailable?.Invoke(this, buffer);
}
catch (Exception ex)
{
if (_socket == null)
{
switch ((uint)ex.HResult)
{
// the user closed the socket.
case 0x80072745:
BluetoothErrorAsync?.Invoke(this, new BluetoothException(
BluetoothException.ErrorCodes.ReceiveFailed,
"Disconnect triggered by remote device"));
break;
case 0x800703E3:
Log.Debug(
"WindowsRT.BluetoothService: The I/O operation has been aborted because of either a thread exit or an application request");
break;
}
}
else
{
BluetoothErrorAsync?.Invoke(this, new BluetoothException(
BluetoothException.ErrorCodes.ReceiveFailed,
"Failed to read stream: " + ex.Message));
}
await DisconnectAsync();
}
}
}
private void BluetoothServiceLoop()
{
Stream?peerStream = null;
while (true)
{
try
{
_cancelSource.Token.ThrowIfCancellationRequested();
Task.Delay(50).Wait(_cancelSource.Token);
}
catch (OperationCanceledException)
{
peerStream?.Close();
_client?.Close();
throw;
}
if (_client == null || !_client.Connected)
{
continue;
}
if (peerStream == null)
{
lock (_btlock)
{
if (!_client.Connected)
{
continue;
}
peerStream = _client.GetStream();
}
RfcommConnected?.Invoke(this, EventArgs.Empty);
continue;
}
var available = _client.Available;
if (available > 0 && peerStream.CanRead)
{
byte[] buffer = new byte[available];
try
{
peerStream.Read(buffer, 0, available);
}
catch (SocketException ex)
{
Log.Error($"Windows.BluetoothService: BluetoothServiceLoop: SocketException thrown while reading from socket: {ex.Message}. Cancelled.");
BluetoothErrorAsync?.Invoke(this, new BluetoothException(BluetoothException.ErrorCodes.ReceiveFailed, ex.Message));
return;
}
catch (IOException ex)
{
Log.Error($"Windows.BluetoothService: BluetoothServiceLoop: IOException thrown while writing to socket: {ex.Message}. Cancelled.");
BluetoothErrorAsync?.Invoke(this, new BluetoothException(BluetoothException.ErrorCodes.ReceiveFailed, ex.Message));
}
if (buffer.Length > 0)
{
NewDataAvailable?.Invoke(this, buffer);
}
}
lock (TransmitterQueue)
{
if (TransmitterQueue.Count <= 0)
{
continue;
}
if (!TransmitterQueue.TryDequeue(out var raw))
{
continue;
}
try
{
peerStream.Write(raw, 0, raw.Length);
}
catch (SocketException ex)
{
Log.Error($"Windows.BluetoothService: BluetoothServiceLoop: SocketException thrown while writing to socket: {ex.Message}. Cancelled.");
BluetoothErrorAsync?.Invoke(this, new BluetoothException(BluetoothException.ErrorCodes.SendFailed, ex.Message));
}
catch (IOException ex)
{
Log.Error($"Windows.BluetoothService: BluetoothServiceLoop: IOException thrown while writing to socket: {ex.Message}. Cancelled.");
BluetoothErrorAsync?.Invoke(this, new BluetoothException(BluetoothException.ErrorCodes.SendFailed, ex.Message));
}
}
}
}
public static void signalNewData(int mode, int sessionNumber = 0)
{
signalNewDataMode = mode;
NewDataAvailable?.Invoke(null, new NewDataAvailableArgs(mode, sessionNumber));
}
/// <summary>
/// Event invocator for the <see cref="NewDataAvailable"/> event
/// </summary>
public void OnNewDataAvailable()
{
NewDataAvailable?.Invoke(this, EventArgs.Empty);
}
protected void SignalNewData(DataType dataType, object data)
{
NewDataAvailable?.Invoke(this, new CommunicationData(dataType, data));
}
public static void signalNewData(int mode)
{
signalNewDataMode = mode;
NewDataAvailable?.Invoke(null, EventArgs.Empty);
}
private void StatusUpdateInternal()
{
PackageStatusRequest requestMessage;
PeerOverallStatus[] peersToUpdate;
var elapsed = stopwatch.Elapsed;
var elapsedThresholdRegular = elapsed.Subtract(settings.PeerUpdateStatusTimer);
var elapsedThresholdFast = elapsed.Subtract(settings.PeerUpdateStatusFastTimer);
// prepare list of peers and list of packages we're interested in
lock (syncLock)
{
if (states.Count == 0)
{
return;
}
peersToUpdate = peers.Values
.Where(c => c.LastUpdateTry < (c.UseFastUpdate ? elapsedThresholdFast : elapsedThresholdRegular) && c.DoUpdateStatus)
.ToArray();
if (peersToUpdate.Length == 0)
{
return;
}
foreach (var item in peersToUpdate)
{
item.UseFastUpdate = false; // reset
item.LastUpdateTry = elapsed;
}
requestMessage = new PackageStatusRequest()
{
PackageIds = states.Keys.ToArray()
};
}
logger.LogTrace("Sending update request for {0} package(s) to {1} peer(s).", requestMessage.PackageIds.Length, peersToUpdate.Length);
// build blocks to process and link them
var fetchClientStatusBlock = new TransformBlock <PeerOverallStatus, (PeerOverallStatus peer, PackageStatusResponse result, bool succes)>(
p => FetchClientStatusAsync(p, requestMessage),
new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = ConcurrentStatusUpdates
}
);
var applyClientStatusBlock = new ActionBlock <(PeerOverallStatus peer, PackageStatusResponse result, bool success)>(
p => ApplyClientStatus(p, requestMessage),
new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = 1
}
);
fetchClientStatusBlock.LinkTo(applyClientStatusBlock, new DataflowLinkOptions()
{
PropagateCompletion = true
});
// send
foreach (var peerToUpdate in peersToUpdate)
{
fetchClientStatusBlock.Post(peerToUpdate);
}
fetchClientStatusBlock.Complete();
applyClientStatusBlock.Completion.Wait();
// apply downloads
NewDataAvailable?.Invoke();
}
public void OnNewDataAvailable()
{
NewDataAvailable?.Invoke();
}
