private async Task ReceiveC2dMessagesPollingAndCompleteAsync(CancellationToken ct) { Console.WriteLine($"{DateTime.Now}> Trying to receive C2D messages by polling using the ReceiveAsync() method. Press 'n' to move to the next phase."); while (!ct.IsCancellationRequested) { if (Console.IsInputRedirected || // the pipeline doesn't have a console or redirects console input (Console.KeyAvailable && ConsoleKey.N == Console.ReadKey().Key)) { Console.WriteLine($"\n{DateTime.Now}> Ending message polling."); break; } using Message receivedMessage = await _deviceClient.ReceiveAsync(ct); if (receivedMessage == null) { continue; } Console.WriteLine($"{DateTime.Now}> Polling using ReceiveAsync() - received message with Id={receivedMessage.MessageId}"); PrintMessage(receivedMessage); await _deviceClient.CompleteAsync(receivedMessage, ct); Console.WriteLine($"{DateTime.Now}> Completed C2D message with Id={receivedMessage.MessageId}."); } }
private async Task ReceiveC2dMessagesPollingAndComplete(TimeSpan timeout) { var sw = new Stopwatch(); sw.Start(); Console.WriteLine($"{DateTime.Now}> Receiving C2D messages on the polling ReceiveAsync()."); while (sw.Elapsed < timeout) { using Message receivedMessage = await _deviceClient.ReceiveAsync(timeout); if (receivedMessage == null) { Console.WriteLine($"{DateTime.Now}> Polling ReceiveAsync() - no message received."); await Task.Delay(s_sleepDuration); continue; } Console.WriteLine($"{DateTime.Now}> Polling ReceiveAsync() - received message with Id={receivedMessage.MessageId}"); ProcessReceivedMessage(receivedMessage); await _deviceClient.CompleteAsync(receivedMessage); Console.WriteLine($"{DateTime.Now}> Completed C2D message with Id={receivedMessage.MessageId}."); } sw.Stop(); }
public async void ReceiveDataFromAzure() { Message receivedMessage; string messageData; while (true) { receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage != null) { try { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); if (messageData == "driveGangnamStation") { var uri = new Uri(@"ms-drive-to:?destination.latitude=37.497942&destination.longitude=127.027621&destination.name=Gangnam Station"); await Launcher.LaunchUriAsync(uri); await deviceClient.CompleteAsync(receivedMessage); } else if (messageData == "driveHancomTower") { var uri = new Uri(@"ms-drive-to:?destination.latitude=37.400696&destination.longitude=127.112183&destination.name=Hancom Tower"); await Launcher.LaunchUriAsync(uri); await deviceClient.CompleteAsync(receivedMessage); } else if (messageData == "walkGangnamStation") { var uri = new Uri(@"ms-walk-to:?destination.latitude=37.497942&destination.longitude=127.027621&destination.name=Gangnam Station"); await Launcher.LaunchUriAsync(uri); await deviceClient.CompleteAsync(receivedMessage); } else if (messageData == "walkHancomTower") { var uri = new Uri(@"ms-walk-to:?destination.latitude=37.400696&destination.longitude=127.112183&destination.name=Hancom Tower"); await Launcher.LaunchUriAsync(uri); await deviceClient.CompleteAsync(receivedMessage); } } catch { return; } } } }
async Task CleanupDeviceQueueAsync(string hostname, Device device) { await Task.Delay(TimeSpan.FromSeconds(1)); DeviceClient deviceClient = null; try { deviceClient = DeviceClient.Create( hostname, new DeviceAuthenticationWithRegistrySymmetricKey(this.deviceId, device.Authentication.SymmetricKey.PrimaryKey)); while (true) { using (Client.Message message = await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(2))) { if (message == null) { break; } if (message.LockToken != null) { await deviceClient.CompleteAsync(message.LockToken); } } } } finally { if (deviceClient != null) { await deviceClient.CloseAsync(); } } }
public async Task ReceiveDataFromAzureAsync() { Message receivedMessage; string messageData; while (true) { receivedMessage = await m_clt.ReceiveAsync(); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); //Wykonanie polecenia if (messageData.Length >= 1) { await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { m_col.Add(messageData); }); } //await m_deviceClient.RejectAsync(receivedMessage); //await m_deviceClient.AbandonAsync(receivedMessage); - odrzuca, ale komunikat wraca //Potwierdzenie wykonania await m_clt.CompleteAsync(receivedMessage); //potwierdza odebranie } } }
/// <summary> /// ReceiveCloudMessageAsync() receives a cloud message, but rather than processing the message directly it uses an event /// to send all listeners notification /// </summary> public static async void ReceiveCloudMessageAsync() { Console.WriteLine("\nReceiving cloud to device messages from service"); while (true) { try { Microsoft.Azure.Devices.Client.Message receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage == null) { continue; } DeviceMessageEventArgs eventArgs = new DeviceMessageEventArgs(Encoding.ASCII.GetString(receivedMessage.GetBytes())); ReceivedMessage?.Invoke(receivedMessage, eventArgs); Console.WriteLine($"Received message: {eventArgs.ReceivedMessage}"); await deviceClient.CompleteAsync(receivedMessage); } catch (Exception ex) { Console.WriteLine($"{Utils.FormatExceptionMessage(ex)}"); throw ex; } } }
async Task ReceiveCommands() { Debug.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Message receivedMessage; string messageData; while (true) { try { receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); txtReceivedCommand.Text = messageData; Debug.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); await deviceClient.CompleteAsync(receivedMessage); } } catch (Exception ex) { Debug.WriteLine("IoT Hub Receive Failed."); Debug.WriteLine(ex.Message); } await Task.Delay(TimeSpan.FromSeconds(10)); } }
private static async Task ReceiveMessageWithoutTimeoutCheckAsync(DeviceClient dc, TimeSpan bufferTime, MsTestLogger logger) { var sw = new Stopwatch(); while (true) { try { logger.Trace($"{nameof(ReceiveMessageWithoutTimeoutCheckAsync)} - Calling ReceiveAsync()"); sw.Restart(); using Client.Message message = await dc.ReceiveAsync().ConfigureAwait(false); sw.Stop(); logger.Trace($"{nameof(ReceiveMessageWithoutTimeoutCheckAsync)} - Received message={message}; time taken={sw.ElapsedMilliseconds} ms"); if (message == null) { break; } await dc.CompleteAsync(message).ConfigureAwait(false); } finally { TimeSpan maxLatency = TimeSpan.FromMilliseconds(dc.OperationTimeoutInMilliseconds) + bufferTime; if (sw.Elapsed > maxLatency) { Assert.Fail($"ReceiveAsync did not return in {maxLatency}, instead it took {sw.Elapsed}."); } } } }
public async Task <string> ReceiveCommand() { Debug.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Message receivedMessage; string messageData; while (true) { receivedMessage = await this.deviceClient.ReceiveAsync(); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Debug.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); await deviceClient.CompleteAsync(receivedMessage); return(messageData); } // Note: In this sample, the polling interval is set to // 10 seconds to enable you to see messages as they are sent. // To enable an IoT solution to scale, you should extend this // interval. For example, to scale to 1 million devices, set // the polling interval to 25 minutes. // For further information, see // https://azure.microsoft.com/documentation/articles/iot-hub-devguide/#messaging await Task.Delay(TimeSpan.FromSeconds(10)); } }
private async void cmd07SubscribeAndWaitForMessage_Click(object sender, RoutedEventArgs e) { DeviceClient dc = DeviceClient.CreateFromConnectionString(m_devConnection, Microsoft.Azure.Devices.Client.TransportType.Amqp); //MQTT - ok, but no AbadonAsync await dc.OpenAsync(); Debug.WriteLine("Waiting for message!"); bool end = false; while (!end) { var msg = await dc.ReceiveAsync(TimeSpan.FromSeconds(500)); if (msg != null) { Debug.WriteLine($"{msg.MessageId} - {Encoding.ASCII.GetString(msg.GetBytes())}"); if (msg.DeliveryCount > 1) { await dc.CompleteAsync(msg); end = true; Debug.WriteLine($"{msg.MessageId} - OK"); } else { await dc.AbandonAsync(msg); //Not working in MQTT (due to protocol characteristics) // dc.RejectAsync - doszło ale odrzycamy Debug.WriteLine($"{msg.MessageId} - AbadonAsync"); } } } }
private static async void ReceiveMessageFromCloud(object sender, DoWorkEventArgs e) { while (true) { var message = await deviceClient.ReceiveAsync(); // Check if message was received if (message == null) { continue; } try { Console.WriteLine($"Command Received: {message.Properties["Command"]}"); var messageToSend = JsonConvert.SerializeObject(BuildResponse(message.Properties["Command"])); Console.WriteLine($"Sending response: {messageToSend}"); await deviceClient.CompleteAsync(message); Console.WriteLine("CompleteAsync Done"); await deviceClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes(messageToSend))); Console.WriteLine("Response sent"); } catch (Exception exception) { Console.WriteLine(exception); await deviceClient.RejectAsync(message); } } }
static async Task ReceiveCommands(DeviceClient deviceClient) { Console.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Message receivedMessage; string messageData; while (true) { receivedMessage = await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(1)).ConfigureAwait(false); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); int propCount = 0; foreach (var prop in receivedMessage.Properties) { Console.WriteLine("\t\tProperty[{0}> Key={1} : Value={2}", propCount++, prop.Key, prop.Value); } await deviceClient.CompleteAsync(receivedMessage).ConfigureAwait(false); } } }
/// <summary> /// Receive C2D message(running without iot edge) /// </summary> /// <param name="userContext"></param> /// <returns></returns> static async Task Receive(object userContext) { var userContextValues = userContext as Tuple <DeviceClient, Slaves.ModuleHandle>; if (userContextValues == null) { throw new InvalidOperationException("UserContext doesn't contain " + "expected values"); } DeviceClient ioTHubModuleClient = userContextValues.Item1; var timeout = TimeSpan.FromSeconds(3); while (m_run) { try { Message message = await ioTHubModuleClient.ReceiveAsync(timeout); if (message != null) { await PipeMessage(message, userContext); await ioTHubModuleClient.CompleteAsync(message); } } catch (Exception ex) { Console.WriteLine(); Console.WriteLine("Error when receiving: {0}", ex.Message); } } }
private async void ReceiveC2dAsync() { Console.WriteLine("\nReceiving cloud to device messages from service"); while (true) { Message receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage == null) { continue; } Console.ForegroundColor = ConsoleColor.Yellow; var msg = Encoding.ASCII.GetString(receivedMessage.GetBytes()); var obj = JsonConvert.DeserializeObject <DeviceCommand>(msg); if (obj != null) { ChangeRGB(obj); } Console.WriteLine("Received message: {0}", msg); Console.ResetColor(); await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { WriteLog("Receive Message: " + msg); }); await deviceClient.CompleteAsync(receivedMessage); } }
public async static Task ReceiveAsync(DeviceClient deviceClient) { Console.WriteLine("Device sending to messages to IoTHub..."); // DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(DeviceConnectionString, TransportType.Amqp); Message receivedMessage; string messageData; while (true) { receivedMessage = deviceClient.ReceiveAsync().Result; if (receivedMessage != null) { StringBuilder sb = new StringBuilder(); foreach (byte b in receivedMessage.GetBytes()) { sb.Append((char)b); } messageData = sb.ToString(); // dispose string builder sb = null; Console.WriteLine(DateTime.Now.ToLocalTime() + "> Received message: " + messageData); await deviceClient.CompleteAsync(receivedMessage); } Thread.Sleep(3000); } }
public async void checkIoTHubForMessages() { while (true) { try { Microsoft.Azure.Devices.Client.Message IoTMessage = await deviceClient.ReceiveAsync(); if (IoTMessage != null) { string IoTMessageString = Encoding.ASCII.GetString(IoTMessage.GetBytes()); Dictionary <string, string> thisIsMyProperty = new Dictionary <string, string>(); thisIsMyProperty.Add("source", "IoTHub"); // create a gateway message from IoTMessageString Microsoft.Azure.Devices.Gateway.Message messageToPublish = new Microsoft.Azure.Devices.Gateway.Message("Data: " + IoTMessageString, thisIsMyProperty); this.broker.Publish(messageToPublish); // publish message await deviceClient.CompleteAsync(IoTMessage); // mark the message received Console.WriteLine("received message: " + IoTMessageString); Console.WriteLine(" code not implemented to handle messages. Finish me!"); } } catch { } } }
async static Task MessageReceiveLoop(CancellationToken ct) { // Main Loop while (!ct.IsCancellationRequested) { Message receivedMessage; string messageData; receivedMessage = await _deviceClient.ReceiveAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); // Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); try { imageNumberNext = Convert.ToInt32(messageData, CultureInfo.InvariantCulture); } catch (FormatException) { Console.WriteLine("Error while converting to Int\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); } await _deviceClient.CompleteAsync(receivedMessage).ConfigureAwait(false); } } }
private async void CloudToDeviceAsync() { while (true) { try { Message receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage == null) { await Task.Delay(2000); continue; } await deviceClient.CompleteAsync(receivedMessage); string command = Encoding.ASCII.GetString(receivedMessage.GetBytes()); if (telemetry.SetSampleRateInSeconds(command)) { continue; } T cmd = (T)Convert.ChangeType(command, typeof(T)); CommandReceived?.Invoke(this, new CommandEventArgs <T>(cmd)); } catch { telemetry.Exceptions++; } } }
private static void StartReceiveMessages() { receiveMessageTimer = new Timer(async(state) => { try { Message receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage == null) { return; } var jsonStr = Encoding.ASCII.GetString(receivedMessage.GetBytes()); var req = JsonConvert.DeserializeObject <AppUpdateRequest>(jsonStr); await DownloadDockerImageLocallyAsync(req); await TagDockerImageLocallyAsync(req); await deviceClient.CompleteAsync(receivedMessage); }catch (Exception ex) { Console.WriteLine(ex.Message); } }, null, 0, 1000); }
private static async Task ReceiveMessageWithTimeoutCheckAsync(DeviceClient dc, TimeSpan timeout) { while (true) { var sw = new Stopwatch(); try { sw.Start(); Client.Message message = await dc.ReceiveAsync(timeout).ConfigureAwait(false); sw.Stop(); if (message == null) { break; } await dc.CompleteAsync(message).ConfigureAwait(false); } finally { if (sw.Elapsed > (timeout + s_fiveSeconds)) { Assert.Fail("ReceiveAsync did not return in Operation Timeout time."); } } } }
private async void MainPage_Loaded(object sender, RoutedEventArgs e) { while (true) { // Check, if new messages are available var message = await client.ReceiveAsync(); if (message != null) { // Message received var content = Encoding.ASCII.GetString(message.GetBytes()); if (content.Equals("on")) { // Switch LED on pin.Write(GpioPinValue.High); } else { // Switch LED off pin.Write(GpioPinValue.Low); } // Confirm message processing await client.CompleteAsync(message); } } }
private static async void ReceiveC2dAsync() { Console.WriteLine("\nReceiving cloud to device messages from service"); while (true) { Message receivedMessage = await s_deviceClient.ReceiveAsync(); if (receivedMessage == null) { continue; } Console.ForegroundColor = ConsoleColor.Yellow; var message = Encoding.ASCII.GetString(receivedMessage.GetBytes()); var messageArray = message.Replace(']', ',').Replace('[', ',').Replace('"', ',').Split(',', StringSplitOptions.RemoveEmptyEntries); var intArray = Array.ConvertAll(messageArray, int.Parse); for (int i = 0; i < intArray.Length; i++) { Console.Write(intArray[i] + " "); } Console.WriteLine(); Console.ResetColor(); await s_deviceClient.CompleteAsync(receivedMessage); } }
protected async Task ReceiveMessageAsync(CancellationToken ct) { ExceptionDispatchInfo exInfo = null; _mRecv.ScheduleTime = null; _swRecv.Restart(); try { Task <Client.Message> t = _dc.ReceiveAsync(ct); _mRecv.ScheduleTime = _swRecv.ElapsedMilliseconds; _swRecv.Restart(); Client.Message msg = await t.ConfigureAwait(false); await _dc.CompleteAsync(msg).ConfigureAwait(false); int deviceIdFromMessage = BitConverter.ToInt32(msg.GetBytes()); if (_id != deviceIdFromMessage) { throw new InvalidOperationException($"DeviceId mismatch: Expected {_id} actual {deviceIdFromMessage}."); } } catch (Exception ex) { _mRecv.ErrorMessage = $"{ex.GetType().Name} - {ex.Message}"; exInfo = ExceptionDispatchInfo.Capture(ex); } _mRecv.ExecuteTime = _swRecv.ElapsedMilliseconds; await _writer.WriteAsync(_mRecv).ConfigureAwait(false); exInfo?.Throw(); }
public async Task SignalCompletedCommand(DeserializableCommand command) { if (command == null) { throw new ArgumentNullException("command"); } Debug.Assert( !string.IsNullOrEmpty(command.LockToken), "command.LockToken is a null reference or empty string."); await AzureRetryHelper.OperationWithBasicRetryAsync( async() => { try { await _deviceClient.CompleteAsync(command.LockToken); } catch (Exception ex) { _logger.LogError( "{0}{0}*** Exception: Complete Command ***{0}{0}Command Name: {1}{0}Command: {2}{0}Exception: {3}{0}{0}", Console.Out.NewLine, command.CommandName, command.CommandHistory, ex); } }); }
static async Task ReceiveCommands(DeviceClient deviceClient) { Console.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Message receivedMessage; string messageData; while (true) { receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); int propCount = 0; foreach (var prop in receivedMessage.Properties) { Console.WriteLine("\t\tProperty[{0}> Key={1} : Value={2}", propCount++, prop.Key, prop.Value); } await deviceClient.CompleteAsync(receivedMessage); } // Note: In this sample, the polling interval is set to // 10 seconds to enable you to see messages as they are sent. // To enable an IoT solution to scale, you should extend this // interval. For example, to scale to 1 million devices, set // the polling interval to 25 minutes. // For further information, see // https://azure.microsoft.com/documentation/articles/iot-hub-devguide/#messaging Thread.Sleep(10000); } }
static async Task ReceiveCommands(DeviceClient deviceClient) { Debug.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Message receivedMessage; string messageData; while (true) { receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Debug.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); await deviceClient.CompleteAsync(receivedMessage); } // Note: In this sample, the polling interval is set to // 10 seconds to enable you to see messages as they are sent. // To enable an IoT solution to scale, you should extend this // interval. For example, to scale to 1 million devices, set // the polling interval to 25 minutes. // For further information, see // https://azure.microsoft.com/documentation/articles/iot-hub-devguide/#messaging await Task.Delay(TimeSpan.FromSeconds(10)); } }
static async Task ReceiveCommands(DeviceClient deviceClient) { Console.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Message receivedMessage; string messageData; while (true) { receivedMessage = await deviceClient.ReceiveAsync().ConfigureAwait(false); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); int propCount = 0; foreach (var prop in receivedMessage.Properties) { Console.WriteLine("\t\tProperty[{0}> Key={1} : Value={2}", propCount++, prop.Key, prop.Value); } await deviceClient.CompleteAsync(receivedMessage).ConfigureAwait(false); } // Note: In this sample, the polling interval is set to // 10 seconds to enable you to see messages as they are sent. // To enable an IoT solution to scale, you should extend this // interval. For example, to scale to 1 million devices, set // the polling interval to 25 minutes. // For further information, see // https://azure.microsoft.com/documentation/articles/iot-hub-devguide/#messaging Thread.Sleep(10000); } }
private static async Task RecieveMessageFromCloudAsync() { if (deviceClient != null) { isListening = true; Console.WriteLine("Listening to the Cloud for messages...."); while (true) { var receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage == null) { continue; } var command = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine($"Received message: {command}"); Console.ResetColor(); await deviceClient.CompleteAsync(receivedMessage); if (command != "exit") { continue; } isListening = false; Console.WriteLine("EXIT command received. Stoping to listen..."); break; } } }
public async void ReceiveAsync() { Console.WriteLine("\nReceiving cloud to device messages from service"); while (true) { Message receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage == null) { continue; } Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("Received message: {0}", Encoding.ASCII.GetString(receivedMessage.GetBytes())); Console.ResetColor(); //FIXME: //Works with HTTP //remove the lock, remove from queue //await deviceClient.RejectAsync(receivedMessage); //successfully procedded, remove from queue //Works with HTTP, MQTT. AMQP QOS level 2 await deviceClient.CompleteAsync(receivedMessage); //abondon //remove the lock, keep in the queue //Works with HTTP // await deviceClient.AbandonAsync(receivedMessage); } }
private async Task ReceiveDataFromAzure() { #if IOTHUB while (_azureIoTHubClient != null) { var message = await _azureIoTHubClient.ReceiveAsync(); if (message != null) { try { var msg = new Models.ReceivedMessage(message.GetBytes()); msg.MessageId = message.MessageId; msg.Topic = message.To; DispatcherServices.Invoke(() => ReceivedMessageList.Insert(0, msg)); // Received a new message, display it // We received the message, indicate IoTHub we treated it await _azureIoTHubClient.CompleteAsync(message); } catch { await _azureIoTHubClient.RejectAsync(message); } } } #else await Task.FromResult(default(object)); #endif }
private async Task ReceiveCommands() { Console.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Console.WriteLine("Use the IoT Hub Azure Portal to send a message to this device.\n"); Message receivedMessage; string messageData; receivedMessage = await _deviceClient.ReceiveAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); int propCount = 0; foreach (var prop in receivedMessage.Properties) { Console.WriteLine("\t\tProperty[{0}> Key={1} : Value={2}", propCount++, prop.Key, prop.Value); } await _deviceClient.CompleteAsync(receivedMessage).ConfigureAwait(false); } else { Console.WriteLine("\t{0}> Timed out", DateTime.Now.ToLocalTime()); } }
//------------------------------------------------------------------------------------------------------------------------ public async void ReceiveDataFromAzure() { Message receivedMessage; string messageData; while (true) { receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); await deviceClient.CompleteAsync(receivedMessage); var payload = JsonConvert.DeserializeObject <AzureIOTPayoad>(messageData); if (payload.ThingName == "Led") { led?.SetBrightness(payload.Led); } else if (payload.ThingName == "LCD") { lcd?.Display(payload.LCD, new int[] { 255, 255, 0 }); } } } }
static async Task ReceiveCommands(DeviceClient deviceClient) { Console.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Message receivedMessage; string messageData; while (true) { receivedMessage = await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(1)); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); int propCount = 0; foreach (var prop in receivedMessage.Properties) { Console.WriteLine("\t\tProperty[{0}> Key={1} : Value={2}", propCount++, prop.Key, prop.Value); } await deviceClient.CompleteAsync(receivedMessage); } } }
static async Task ReceiveCommands(DeviceClient deviceClient) { Console.WriteLine("\nDevice waiting for commands from IoTHub...\n"); Message receivedMessage; string messageData; while (true) { receivedMessage = await deviceClient.ReceiveAsync(TimeSpan.FromSeconds(1)); if (receivedMessage != null) { messageData = Encoding.ASCII.GetString(receivedMessage.GetBytes()); Console.WriteLine("\t{0}> Received message: {1}", DateTime.Now.ToLocalTime(), messageData); await deviceClient.CompleteAsync(receivedMessage); } } }