void iothub_client_sample_http_send_one_msg(IOTHUB_CLIENT_HANDLE iothubClient, EVENT_INSTANCE *message, int messageNumber) { if ((message->messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText))) == NULL) { (void)printf("ERROR: iotHubMessageHandle is NULL!\r\n"); } else { MAP_HANDLE propMap; message->messageTrackingId = messageNumber; propMap = IoTHubMessage_Properties(message->messageHandle); sprintf_s(propText, sizeof(propText), "PropMsg_%d", messageNumber); if (Map_AddOrUpdate(propMap, "PropName", propText) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate Failed!\r\n"); } if (IoTHubClient_SendEventAsync(iothubClient, message->messageHandle, SendConfirmationCallback, message) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SendEventAsync to device [%p]..........FAILED!\r\n", iothubClient); } else { (void)printf("IoTHubClient_LL_SendEventAsync accepted message [%d] for transmission to IoT Hub, device [%p].\r\n", messageNumber, iothubClient); } } }
static void sendMessage(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const unsigned char* buffer, size_t size, ContosoAnemometer *myWeather) { static unsigned int messageTrackingId; IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(buffer, size); if (messageHandle == NULL) { printf("unable to create a new IoTHubMessage\r\n"); } else { MAP_HANDLE propMap = IoTHubMessage_Properties(messageHandle); (void)sprintf_s(propText, sizeof(propText), myWeather->Temperature > 28 ? "true" : "false"); if (Map_AddOrUpdate(propMap, "temperatureAlert", propText) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate Failed!\r\n"); } if (IoTHubClient_SendEventAsync(iotHubClientHandle, messageHandle, sendCallback, (void*)(uintptr_t)messageTrackingId) != IOTHUB_CLIENT_OK) { printf("failed to hand over the message to IoTHubClient"); } else { printf("IoTHubClient accepted the message for delivery\r\n"); } IoTHubMessage_Destroy(messageHandle); } free((void*)buffer); messageTrackingId++; }
void send_device_to_cloud_message() { if (platform_init() != 0) { printf("Failed initializing platform.\r\n"); return; } // Setup IoTHub client configuration IOTHUB_CLIENT_HANDLE iothub_client_handle = IoTHubClient_CreateFromConnectionString(connection_string, AMQP_Protocol); if (iothub_client_handle == nullptr) { printf("Failed on IoTHubClient_Create\r\n"); } else { std::string message = "Hello, Cloud from C++!"; IOTHUB_MESSAGE_HANDLE message_handle = IoTHubMessage_CreateFromByteArray((const unsigned char*)message.data(), message.size()); if (message_handle == nullptr) { printf("unable to create a new IoTHubMessage\n"); } else { callback_parameter callback_param = { message }; if (IoTHubClient_SendEventAsync(iothub_client_handle, message_handle, send_callback, &callback_param) != IOTHUB_CLIENT_OK) { printf("failed to hand over the message to IoTHubClient"); } else { printf("IoTHubClient accepted the message for delivery\n"); } IoTHubMessage_Destroy(message_handle); callback_param.completion.get_future().wait(); } printf("Done!\n"); } IoTHubClient_Destroy(iothub_client_handle); platform_deinit(); }
static void sendMessage(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const unsigned char* buffer, size_t size) { IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(buffer, size); if (messageHandle == NULL) { (void)printf("unable to create a new IoTHubMessage\r\n"); } else { if (IoTHubClient_SendEventAsync(iotHubClientHandle, messageHandle, NULL, NULL) != IOTHUB_CLIENT_OK) { (void)printf("failed to hand over the message to IoTHubClient\r\n"); } else { (void)printf("IoTHubClient accepted the message for delivery\r\n"); } IoTHubMessage_Destroy(messageHandle); } free((void*)buffer); }
static void sendMessage(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const unsigned char* buffer, size_t size) { static unsigned int messageTrackingId; IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(buffer, size); if (messageHandle == NULL) { printf("unable to create a new IoTHubMessage\r\n"); } else { if (IoTHubClient_SendEventAsync(iotHubClientHandle, messageHandle, sendCallback, (void*)(uintptr_t)messageTrackingId) != IOTHUB_CLIENT_OK) { printf("failed to hand over the message to IoTHubClient"); } else { printf("IoTHubClient accepted the message for delivery\r\n"); } IoTHubMessage_Destroy(messageHandle); } free((void*)buffer); messageTrackingId++; }
void iothub_client_sample_amqp_websockets_run(void) { IOTHUB_CLIENT_HANDLE iotHubClientHandle; EVENT_INSTANCE messages[MESSAGE_COUNT]; srand((unsigned int)time(NULL)); double avgWindSpeed = 10.0; double minTemperature = 20.0; double minHumidity = 60.0; double temperature = 0; double humidity = 0; callbackCounter = 0; int receiveContext = 0; (void)printf("Starting the IoTHub client sample AMQP over WebSockets...\r\n"); if (platform_init() != 0) { (void)printf("ERROR: failed initializing the platform.\r\n"); } else if ((iotHubClientHandle = IoTHubClient_CreateFromConnectionString(connectionString, AMQP_Protocol_over_WebSocketsTls)) == NULL) { (void)printf("ERROR: iotHubClientHandle is NULL!\r\n"); platform_deinit(); } else { // For mbed add the certificate information if (IoTHubClient_SetOption(iotHubClientHandle, "TrustedCerts", certificates) != IOTHUB_CLIENT_OK) { printf("failure to set option \"TrustedCerts\"\r\n"); } /* Setting Message call back, so we can receive Commands. */ if (IoTHubClient_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, &receiveContext) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SetMessageCallback..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SetMessageCallback...successful.\r\n"); /* Now that we are ready to receive commands, let's send some messages */ for (size_t i = 0; i < MESSAGE_COUNT; i++) { temperature = minTemperature + (rand() % 10); humidity = minHumidity + (rand() % 20); sprintf_s(msgText, sizeof(msgText), "{\"deviceId\":\"myFirstDevice\",\"windSpeed\":%.2f,\"temperature\":%.2f,\"humidity\":%.2f}", avgWindSpeed + (rand() % 4 + 2), temperature, humidity); if ((messages[i].messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText))) == NULL) { (void)printf("ERROR: iotHubMessageHandle is NULL!\r\n"); } else { messages[i].messageTrackingId = (int)i; MAP_HANDLE propMap = IoTHubMessage_Properties(messages[i].messageHandle); (void)sprintf_s(propText, sizeof(propText), temperature > 28 ? "true" : "false"); if (Map_AddOrUpdate(propMap, "temperatureAlert", propText) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate Failed!\r\n"); } if (IoTHubClient_SendEventAsync(iotHubClientHandle, messages[i].messageHandle, SendConfirmationCallback, &messages[i]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SendEventAsync..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SendEventAsync accepted data for transmission to IoT Hub.\r\n"); } } } /* Wait for Commands. */ (void)printf("Press any key to exit the application. \r\n"); (void)getchar(); } IoTHubClient_Destroy(iotHubClientHandle); platform_deinit(); } }
static void SendEvent(IOTHUB_PROVISIONED_DEVICE* deviceToUse) { // arrange IOTHUB_CLIENT_HANDLE iotHubClientHandle; IOTHUB_MESSAGE_HANDLE msgHandle; EXPECTED_SEND_DATA* sendData = EventData_Create(); ASSERT_IS_NOT_NULL(sendData, "Failure creating data to be sent"); // Send the Event { IOTHUB_CLIENT_RESULT result; // Create the IoT Hub Data iotHubClientHandle = IoTHubClient_CreateFromConnectionString(deviceToUse->connectionString, HTTP_Protocol); ASSERT_IS_NOT_NULL(iotHubClientHandle, "Failure creating IothubClient handle"); msgHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)sendData->expectedString, strlen(sendData->expectedString)); ASSERT_IS_NOT_NULL(msgHandle, "Failure to create message handle"); if (deviceToUse->howToCreate == IOTHUB_ACCOUNT_AUTH_X509) { result = IoTHubClient_SetOption(iotHubClientHandle, OPTION_X509_CERT, deviceToUse->certificate); ASSERT_ARE_EQUAL(IOTHUB_CLIENT_RESULT, IOTHUB_CLIENT_OK, result, "Could not set the device x509 certificate"); result = IoTHubClient_SetOption(iotHubClientHandle, OPTION_X509_PRIVATE_KEY, deviceToUse->primaryAuthentication); ASSERT_ARE_EQUAL(IOTHUB_CLIENT_RESULT, IOTHUB_CLIENT_OK, result, "Could not set the device x509 privateKey"); } // act result = IoTHubClient_SendEventAsync(iotHubClientHandle, msgHandle, ReceiveConfirmationCallback, sendData); ASSERT_ARE_EQUAL(IOTHUB_CLIENT_RESULT, IOTHUB_CLIENT_OK, result, "Failure calling IoTHubClient_SendEventAsync"); } time_t beginOperation, nowTime; beginOperation = time(NULL); while ( (nowTime = time(NULL)), (difftime(nowTime, beginOperation) < MAX_CLOUD_TRAVEL_TIME) // time box ) { if (Lock(sendData->lock) != LOCK_OK) { ASSERT_FAIL("unable to lock"); } else { if (sendData->dataWasRecv) { Unlock(sendData->lock); break; } Unlock(sendData->lock); } ThreadAPI_Sleep(100); } if (Lock(sendData->lock) != LOCK_OK) { ASSERT_FAIL("unable to lock"); } else { ASSERT_IS_TRUE(sendData->dataWasRecv, "Failure sending data to IotHub"); // was found is written by the callback... (void)Unlock(sendData->lock); } { IOTHUB_TEST_HANDLE iotHubTestHandle = IoTHubTest_Initialize(IoTHubAccount_GetEventHubConnectionString(g_iothubAcctInfo1), IoTHubAccount_GetIoTHubConnString(g_iothubAcctInfo1), deviceToUse->deviceId, IoTHubAccount_GetEventhubListenName(g_iothubAcctInfo1), IoTHubAccount_GetEventhubAccessKey(g_iothubAcctInfo1), IoTHubAccount_GetSharedAccessSignature(g_iothubAcctInfo1), IoTHubAccount_GetEventhubConsumerGroup(g_iothubAcctInfo1)); ASSERT_IS_NOT_NULL(iotHubTestHandle); IOTHUB_TEST_CLIENT_RESULT result = IoTHubTest_ListenForEventForMaxDrainTime(iotHubTestHandle, IoTHubCallback, IoTHubAccount_GetIoTHubPartitionCount(g_iothubAcctInfo1), sendData); ASSERT_ARE_EQUAL(IOTHUB_TEST_CLIENT_RESULT, IOTHUB_TEST_CLIENT_OK, result); IoTHubTest_Deinit(iotHubTestHandle); } // assert ASSERT_IS_TRUE(sendData->wasFound, "Failure receiving data from eventhub"); // was found is written by the callback...*/ // cleanup IoTHubMessage_Destroy(msgHandle); IoTHubClient_Destroy(iotHubClientHandle); EventData_Destroy(sendData); }
static int sendEventLoop(IOTHUB_CLIENT_HANDLE iotHubClientHandle, LONGHAUL_SEND_TEST_STATE* test_state) { int result = 0; #ifndef MBED_BUILD_TIMESTAMP IOTHUB_TEST_HANDLE iotHubTestHandle; if ((iotHubTestHandle = IoTHubTest_Initialize(IoTHubAccount_GetEventHubConnectionString(g_iothubAcctInfo), IoTHubAccount_GetIoTHubConnString(g_iothubAcctInfo), IoTHubAccount_GetDeviceId(g_iothubAcctInfo), IoTHubAccount_GetDeviceKey(g_iothubAcctInfo), IoTHubAccount_GetEventhubListenName(g_iothubAcctInfo), IoTHubAccount_GetEventhubAccessKey(g_iothubAcctInfo), IoTHubAccount_GetSharedAccessSignature(g_iothubAcctInfo), IoTHubAccount_GetEventhubConsumerGroup(g_iothubAcctInfo))) == NULL) { LogError("Failed initializing the Event Hub test client."); result = __LINE__; } else { initializeSendStatistics(&test_state->statistics); #endif time_t testInitialTime; if ((testInitialTime = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting the initial time of the test (time(NULL) failed)."); result = __LINE__; } else { time_t loopIterationStartTimeInSeconds, loopIterationEndTimeInSeconds; double loopIterationTotalTime; time_t testCurrentTime; while (result == 0) { if ((testCurrentTime = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting the current time of the test (time(NULL) failed)"); result = __LINE__; break; } else if (difftime(testCurrentTime, testInitialTime) > test_state->profile->totalRunTimeInSeconds) { LogInfo("Test run for the expected duration (%d seconds)", test_state->profile->totalRunTimeInSeconds); break; } if ((loopIterationStartTimeInSeconds = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting the initial time of the send/receive loop (time(NULL) failed)"); result = __LINE__; break; } if (test_state->timeUntilNextSendEventInSeconds <= 0.0) { EXPECTED_SEND_DATA* sendData; IOTHUB_MESSAGE_HANDLE msgHandle; if ((sendData = EventData_Create()) == NULL) { LogError("Failed creating EXPECTED_SEND_DATA."); result = __LINE__; } else { if ((msgHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)sendData->expectedString, strlen(sendData->expectedString))) == NULL) { LogError("Failed creating IOTHUB_MESSAGE_HANDLE."); result = __LINE__; } else { if (IoTHubClient_SendEventAsync(iotHubClientHandle, msgHandle, SendConfirmationCallback, sendData) != IOTHUB_CLIENT_OK) { LogError("Call to IoTHubClient_SendEventAsync failed."); result = __LINE__; } else { bool dataWasSent = false; time_t beginOperation, nowTime; if ((beginOperation = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting beginOperation (time(NULL) failed)."); result = __LINE__; } else { do { if (Lock(sendData->lock) != LOCK_OK) { LogError("Unable to lock to flag event sent."); break; } else { if (sendData->dataWasSent) { dataWasSent = true; Unlock(sendData->lock); break; } Unlock(sendData->lock); } ThreadAPI_Sleep(100); if ((nowTime = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting nowTime (time(NULL) failed)."); result = __LINE__; break; } } while (difftime(nowTime, beginOperation) < MAX_CLOUD_TRAVEL_TIME); if (!dataWasSent) { LogError("Failure sending data to IotHub"); result = __LINE__; } else { #ifdef MBED_BUILD_TIMESTAMP if (verifyEventReceivedByHub(sendData) != 0) { result = __LINE__; } else { #else if (verifyEventReceivedByHub(sendData, iotHubTestHandle) != 0) { result = __LINE__; } else { computeSendStatistics(&test_state->statistics, sendData); #endif test_state->timeUntilNextSendEventInSeconds = test_state->profile->eventFrequencyInSecs[test_state->sendFrequencyIndex]; if ((test_state->sendFrequencyIndex + 1) < test_state->profile->numberOfEventFrequencyVariations) test_state->sendFrequencyIndex++; } } } } IoTHubMessage_Destroy(msgHandle); } EventData_Destroy(sendData); } } ThreadAPI_Sleep(500); if ((loopIterationEndTimeInSeconds = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting the end time of the send loop iteration (time(NULL) failed)"); result = __LINE__; } else { loopIterationTotalTime = difftime(loopIterationEndTimeInSeconds, loopIterationStartTimeInSeconds); test_state->timeUntilNextSendEventInSeconds -= loopIterationTotalTime; } } // While loop } #ifndef MBED_BUILD_TIMESTAMP printSendStatistics(&test_state->statistics); IoTHubTest_Deinit(iotHubTestHandle); } #endif return result; } static int receiveMessageLoop(IOTHUB_CLIENT_HANDLE iotHubClientHandle, LONGHAUL_RECEIVE_TEST_STATE* test_state) { int result = 0; #ifndef MBED_BUILD_TIMESTAMP IOTHUB_TEST_HANDLE iotHubTestHandle; if ((iotHubTestHandle = IoTHubTest_Initialize(IoTHubAccount_GetEventHubConnectionString(g_iothubAcctInfo), IoTHubAccount_GetIoTHubConnString(g_iothubAcctInfo), IoTHubAccount_GetDeviceId(g_iothubAcctInfo), IoTHubAccount_GetDeviceKey(g_iothubAcctInfo), IoTHubAccount_GetEventhubListenName(g_iothubAcctInfo), IoTHubAccount_GetEventhubAccessKey(g_iothubAcctInfo), IoTHubAccount_GetSharedAccessSignature(g_iothubAcctInfo), IoTHubAccount_GetEventhubConsumerGroup(g_iothubAcctInfo))) == NULL) { LogError("Failed initializing the Event Hub test client."); result = __LINE__; } else { initializeReceiveStatistics(&test_state->statistics); #endif time_t testInitialTime; if ((testInitialTime = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting the initial time of the test (time(NULL) failed)."); result = __LINE__; } else { time_t loopIterationStartTimeInSeconds, loopIterationEndTimeInSeconds; double loopIterationTotalTime; time_t testCurrentTime; while (result == 0) { if ((testCurrentTime = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting the current time of the test (time(NULL) failed)"); result = __LINE__; break; } else if (difftime(testCurrentTime, testInitialTime) > test_state->profile->totalRunTimeInSeconds) { LogInfo("Test run for the expected duration (%d seconds)", test_state->profile->totalRunTimeInSeconds); break; } if ((loopIterationStartTimeInSeconds = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting the initial time of the receive loop iteration (time(NULL) failed)"); result = __LINE__; break; } if (test_state->timeUntilNextReceiveMessageInSeconds <= 0.0) { EXPECTED_RECEIVE_DATA* receiveData; if ((receiveData = MessageData_Create()) == NULL) { LogError("Failed creating EXPECTED_RECEIVE_DATA."); result = __LINE__; } else { IOTHUB_TEST_CLIENT_RESULT sendResult; if (IoTHubClient_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, receiveData) != IOTHUB_CLIENT_OK) { LogError("Call to IoTHubClient_SetMessageCallback failed."); result = __LINE__; } else if ((sendResult = IoTHubTest_SendMessage(iotHubTestHandle, (const unsigned char*)receiveData->data, receiveData->dataSize)) != IOTHUB_TEST_CLIENT_OK) { LogError("Call to IoTHubTest_SendMessage failed (%i).", sendResult); result = __LINE__; } else { if ((receiveData->timeSent = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting receiveData->timeSent (time(NULL) failed)"); } time_t beginOperation, nowTime; if ((beginOperation = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting beginOperation (time(NULL) failed)."); result = __LINE__; } else { do { if (Lock(receiveData->lock) != LOCK_OK) { LogError("Unable to lock to verify if C2D message has been received."); result = __LINE__; break; } else { if (receiveData->receivedByClient) { (void)Unlock(receiveData->lock); break; } (void)Unlock(receiveData->lock); } ThreadAPI_Sleep(100); if ((nowTime = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting nowTime (time(NULL) failed)."); result = __LINE__; break; } } while (difftime(nowTime, beginOperation) < MAX_CLOUD_TRAVEL_TIME); if (result == 0) { if (!receiveData->receivedByClient) { LogError("Failure retrieving data from C2D"); result = __LINE__; } else { #ifndef MBED_BUILD_TIMESTAMP computeReceiveStatistics(&test_state->statistics, receiveData); #endif test_state->timeUntilNextReceiveMessageInSeconds = test_state->profile->messageFrequencyInSecs[test_state->receiveFrequencyIndex]; if ((test_state->receiveFrequencyIndex + 1) < test_state->profile->numberOfMessageFrequencyVariations) test_state->receiveFrequencyIndex++; } } } } MessageData_Destroy(receiveData); } } ThreadAPI_Sleep(500); if ((loopIterationEndTimeInSeconds = time(NULL)) == INDEFINITE_TIME) { LogError("Failed setting the end time of the receive loop iteration (time(NULL) failed)"); result = __LINE__; } else { loopIterationTotalTime = difftime(loopIterationEndTimeInSeconds, loopIterationStartTimeInSeconds); test_state->timeUntilNextReceiveMessageInSeconds -= loopIterationTotalTime; } } // While loop } #ifndef MBED_BUILD_TIMESTAMP printReceiveStatistics(&test_state->statistics); IoTHubTest_Deinit(iotHubTestHandle); } #endif return result; }
void iothub_client_sample_amqp_run(void) { IOTHUB_CLIENT_HANDLE iotHubClientHandle; EVENT_INSTANCE messages[MESSAGE_COUNT]; srand((unsigned int)time(NULL)); double avgWindSpeed = 10.0; callbackCounter = 0; int receiveContext = 0; (void)printf("Starting the IoTHub client sample AMQP...\r\n"); if ((iotHubClientHandle = IoTHubClient_CreateFromConnectionString(connectionString, AMQP_Protocol)) == NULL) { (void)printf("ERROR: iotHubClientHandle is NULL!\r\n"); } else { #ifdef MBED_BUILD_TIMESTAMP // For mbed add the certificate information if (IoTHubClient_SetOption(iotHubClientHandle, "TrustedCerts", certificates) != IOTHUB_CLIENT_OK) { printf("failure to set option \"TrustedCerts\"\r\n"); } #endif // MBED_BUILD_TIMESTAMP /* Setting Message call back, so we can receive Commands. */ if (IoTHubClient_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, &receiveContext) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SetMessageCallback..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SetMessageCallback...successful.\r\n"); /* Now that we are ready to receive commands, let's send some messages */ for (size_t i = 0; i < MESSAGE_COUNT; i++) { sprintf_s(msgText, sizeof(msgText), "{\"deviceId\":\"myFirstDevice\",\"windSpeed\":%.2f}", avgWindSpeed+(rand()%4+2) ); if ((messages[i].messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText))) == NULL) { (void)printf("ERROR: iotHubMessageHandle is NULL!\r\n"); } else { messages[i].messageTrackingId = i; MAP_HANDLE propMap = IoTHubMessage_Properties(messages[i].messageHandle); sprintf_s(propText, sizeof(propText), "PropMsg_%d", i); if (Map_AddOrUpdate(propMap, "PropName", propText) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate Failed!\r\n"); } if (IoTHubClient_SendEventAsync(iotHubClientHandle, messages[i].messageHandle, SendConfirmationCallback, &messages[i]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SendEventAsync..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SendEventAsync accepted data for transmission to IoT Hub.\r\n"); } } } /* Wait for Commands. */ (void)printf("Press any key to exit the application. \r\n"); (void)getchar(); } IoTHubClient_Destroy(iotHubClientHandle); } }