private async Task SendCommand(CommandId commandId)
{
if (serialDevice != null)
{
byte[] command = null;
switch (commandId)
{
case CommandId.BlinkingFrequency:
command = CommandHelper.PrepareSetFrequencyCommand(hzBlinkingFrequency);
break;
case CommandId.BlinkingStatus:
command = CommandHelper.PrepareBlinkingStatusCommand(isLedBlinking);
break;
}
await SerialCommunicationHelper.WriteBytes(serialDevice, command);
DiagnosticInfo.Display(diagnosticData, "Data written: " + CommandHelper.CommandToString(command));
}
else
{
DiagnosticInfo.Display(diagnosticData, "No active connection");
}
}
private void StreamSocketListener_ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
{
DiagnosticInfo.Display(null, "Client has been connected");
streamSocket = args.Socket;
StartCommunicationListener();
}
private async Task InitializeUI()
{
await GetDeviceList();
var devicesCount = devicesList.Count;
isLedBlinking = false;
DiagnosticInfo.Display(diagnosticData, "Initialized. Number of available devices: " + devicesCount);
}
private void SenseHatLedArrayWatcher_Stopped(SenseHatLedArrayWatcher sender,
AllJoynProducerStoppedEventArgs args)
{
isSenseHatAvailable = false;
senseHatLedArrayConsumer.Dispose();
senseHatLedArrayConsumer = null;
DiagnosticInfo.Display(diagnosticData,
"SenseHatLedArray AllJoyn device left the network");
}
private async void ButtonConnect_Click(object sender, RoutedEventArgs e)
{
try
{
await SetupConnection();
}
catch (Exception ex)
{
DiagnosticInfo.Display(diagnosticData, ex.Message);
}
}
private async void SenseHatLedArrayWatcher_Added(SenseHatLedArrayWatcher sender,
AllJoynServiceInfo args)
{
var result = await SenseHatLedArrayConsumer.JoinSessionAsync(args, senseHatLedArrayWatcher);
if (result.Status == AllJoynStatus.Ok)
{
isSenseHatAvailable = true;
senseHatLedArrayConsumer = result.Consumer;
DiagnosticInfo.Display(diagnosticData,
"Successfully joined the AllJoyn session. Bus name: " + args.UniqueName);
}
}
private void HandleLedColorCommand(byte[] command)
{
var redChannel = command[CommandHelper.CommandDataBeginIndex];
var greenChannel = command[CommandHelper.CommandDataBeginIndex + 1];
var blueChannel = command[CommandHelper.CommandDataBeginIndex + 2];
var color = Color.FromArgb(0, redChannel, greenChannel, blueChannel);
if (ledArray != null)
{
ledArray.Reset(color);
}
DiagnosticInfo.Display(null, color.ToString() + " " + redChannel + " " + greenChannel + " " + blueChannel);
}
private async Task InitializeLedArray()
{
const byte address = 0x46;
var device = await I2cHelper.GetI2cDevice(address);
if (device != null)
{
ledArray = new LedArray(device);
ledArray.Reset(Colors.Black);
}
else
{
DiagnosticInfo.Display(null, "Led array unavailable");
}
}
private async Task WriteTestMessage()
{
if (dataWriter != null)
{
dataWriter.WriteString(testMessage);
var bytesWritten = await dataWriter.StoreAsync();
DiagnosticInfo.Display(diagnosticData, "Test message written successfully. Bytes written: " + bytesWritten);
}
else
{
DiagnosticInfo.Display(diagnosticData, "Data writer has been not initialized");
}
}
private async void ButtonTurnOff_Click(object sender, RoutedEventArgs e)
{
if (isSenseHatAvailable)
{
var turnOffResult = await senseHatLedArrayConsumer.TurnOffAsync();
var allJoynStatus = AllJoynStatusHelper.GetStatusCodeName(turnOffResult.Status);
DiagnosticInfo.Display(diagnosticData, "Turn off method result: " + allJoynStatus);
}
else
{
DiagnosticInfo.Display(diagnosticData, deviceUnavailable);
}
}
private async void ButtonSendColor_Click(object sender, RoutedEventArgs e)
{
if (streamSocket != null)
{
var commandData = CommandHelper.PrepareLedColorCommand(senseHatColor.Brush.Color);
await SerialCommunicationHelper.WriteBytes(streamSocket.OutputStream, commandData);
DiagnosticInfo.Display(diagnosticData, CommandHelper.CommandToString(commandData));
}
else
{
DiagnosticInfo.Display(diagnosticData, "No active connection");
}
}
private async void CommunicationListener()
{
while (true)
{
var commandReceived = await SerialCommunicationHelper.ReadBytes(serialDevice);
try
{
ParseCommand(commandReceived);
}
catch (Exception ex)
{
DiagnosticInfo.Display(null, ex.Message);
}
}
}
private async Task ReadTestMessage()
{
if (dataReader != null)
{
var stringLength = dataWriter.MeasureString(testMessage);
await dataReader.LoadAsync(stringLength);
var messageReceived = dataReader.ReadString(dataReader.UnconsumedBufferLength);
DiagnosticInfo.Display(diagnosticData, "Message received: " + messageReceived);
}
else
{
DiagnosticInfo.Display(diagnosticData, "Data reader has been not initialized");
}
}
private async void ButtonConnect_Click(object sender, RoutedEventArgs e)
{
try
{
var device = await BluetoothCommunicationHelper.GetFirstPairedDeviceAvailable();
await CloseConnection();
streamSocket = await BluetoothCommunicationHelper.Connect(device);
DiagnosticInfo.Display(diagnosticData, "Connected to: " + device.HostName);
}
catch (Exception ex)
{
DiagnosticInfo.Display(diagnosticData, ex.Message);
}
}
private async void ButtonGetShape_Click(object sender, RoutedEventArgs e)
{
if (isSenseHatAvailable)
{
var getShapeResult = await senseHatLedArrayConsumer.GetShapeAsync();
var allJoynStatus = AllJoynStatusHelper.GetStatusCodeName(getShapeResult.Status);
var info = string.Format("Current shape: {0}, Status: {1}",
(ShapeKind)getShapeResult.Shape, allJoynStatus);
DiagnosticInfo.Display(diagnosticData, info);
}
else
{
DiagnosticInfo.Display(diagnosticData, deviceUnavailable);
}
}
private async void ButtonDrawShape_Click(object sender, RoutedEventArgs e)
{
if (isSenseHatAvailable)
{
var drawShapeResult = await senseHatLedArrayConsumer.DrawShapeAsync(
(int)selectedShape);
var allJoynStatus = AllJoynStatusHelper.GetStatusCodeName(
drawShapeResult.Status);
var info = string.Format("Shape drawn: {0}, Status: {1}",
selectedShape, allJoynStatus);
DiagnosticInfo.Display(diagnosticData, info);
}
else
{
DiagnosticInfo.Display(diagnosticData, deviceUnavailable);
}
}
private async void ButtonConnect_Click(object sender, RoutedEventArgs e)
{
try
{
await CloseStreamSocket();
var connectionStatus = await WiFiCommunicationHelper.ConnectToWiFiNetwork();
if (connectionStatus == WiFiConnectionStatus.Success)
{
streamSocket = await WiFiCommunicationHelper.ConnectToHost();
DiagnosticInfo.Display(diagnosticData, "Connected to: " + WiFiCommunicationHelper.Rpi2HostName);
}
}
catch (Exception ex)
{
DiagnosticInfo.Display(diagnosticData, ex.Message);
}
}
private async void CommunicationListener()
{
const int msSleepTime = 50;
while (true)
{
var commandReceived = await SerialCommunicationHelper.ReadBytes(streamSocket.InputStream);
try
{
if (commandReceived.Length > 0)
{
ParseCommand(commandReceived);
}
}
catch (Exception ex)
{
DiagnosticInfo.Display(null, ex.Message);
}
Task.Delay(msSleepTime).Wait();
}
}
private async Task StartRfcommService()
{
var serviceGuid = Guid.Parse("34B1CF4D-1069-4AD6-89B6-E161D79BE4D8");
var serviceId = RfcommServiceId.FromUuid(serviceGuid);
rfcommProvider = await RfcommServiceProvider.CreateAsync(serviceId);
streamSocketListener = new StreamSocketListener();
streamSocketListener.ConnectionReceived += StreamSocketListener_ConnectionReceived;
try
{
await streamSocketListener.BindServiceNameAsync(rfcommProvider.ServiceId.AsString(), SocketProtectionLevel.BluetoothEncryptionAllowNullAuthentication);
rfcommProvider.StartAdvertising(streamSocketListener);
DiagnosticInfo.Display(null, "RFCOMM service started. Waiting for clients...");
}
catch (Exception ex)
{
DiagnosticInfo.Display(null, ex.Message);
}
}
