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 IoTHubClient_LL_Destroy(IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle) { /*Codes_SRS_IOTHUBCLIENT_LL_02_009: [IoTHubClient_LL_Destroy shall do nothing if parameter iotHubClientHandle is NULL.]*/ if (iotHubClientHandle != NULL) { PDLIST_ENTRY unsend; /*Codes_SRS_IOTHUBCLIENT_LL_02_010: [IoTHubClient_LL_Destroy it shall call the underlaying layer's _Destroy function and shall free the resources allocated by IoTHubClient (if any).] */ IOTHUB_CLIENT_LL_HANDLE_DATA* handleData = (IOTHUB_CLIENT_LL_HANDLE_DATA*)iotHubClientHandle; handleData->IoTHubTransport_Destroy(handleData->transportHandle); /*if any, remove the items currently not send*/ while ((unsend = DList_RemoveHeadList(&(handleData->waitingToSend))) != &(handleData->waitingToSend)) { IOTHUB_MESSAGE_LIST* temp = containingRecord(unsend, IOTHUB_MESSAGE_LIST, entry); /*Codes_SRS_IOTHUBCLIENT_LL_02_033: [Otherwise, IoTHubClient_LL_Destroy shall complete all the event message callbacks that are in the waitingToSend list with the result IOTHUB_CLIENT_CONFIRMATION_BECAUSE_DESTROY.] */ if (temp->callback != NULL) { temp->callback(IOTHUB_CLIENT_CONFIRMATION_BECAUSE_DESTROY, temp->context); } IoTHubMessage_Destroy(temp->messageHandle); free(temp); } free(handleData); } }
void simplesample_http_run(void) { if (serializer_init(NULL) != SERIALIZER_OK) { LogInfo("Failed on serializer_init\r\n"); } else { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, HTTP_Protocol); srand((unsigned int)time(NULL)); int avgWindSpeed = 10.0; if (iotHubClientHandle == NULL) { LogInfo("Failed on IoTHubClient_LL_Create\r\n"); } else { unsigned int minimumPollingTime = 9; /*because it can poll "after 9 seconds" polls will happen effectively at ~10 seconds*/ if (IoTHubClient_LL_SetOption(iotHubClientHandle, "MinimumPollingTime", &minimumPollingTime) != IOTHUB_CLIENT_OK) { LogInfo("failure to set option \"MinimumPollingTime\"\r\n"); } #ifdef MBED_BUILD_TIMESTAMP // For mbed add the certificate information if (IoTHubClient_LL_SetOption(iotHubClientHandle, "TrustedCerts", certificates) != IOTHUB_CLIENT_OK) { LogInfo("failure to set option \"TrustedCerts\"\r\n"); } #endif // MBED_BUILD_TIMESTAMP ContosoAnemometer* myWeather = CREATE_MODEL_INSTANCE(WeatherStation, ContosoAnemometer); if (myWeather == NULL) { LogInfo("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, myWeather) != IOTHUB_CLIENT_OK) { LogInfo("unable to IoTHubClient_SetMessageCallback\r\n"); } else { myWeather->DeviceId = "myFirstDevice"; myWeather->WindSpeed = avgWindSpeed + (rand() % 4 + 2); { unsigned char* destination; size_t destinationSize; if (SERIALIZE(&destination, &destinationSize, myWeather->DeviceId, myWeather->WindSpeed) != IOT_AGENT_OK) { LogInfo("Failed to serialize\r\n"); } else { IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(destination, destinationSize); if (messageHandle == NULL) { LogInfo("unable to create a new IoTHubMessage\r\n"); } else { if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messageHandle, sendCallback, (void*)1) != IOTHUB_CLIENT_OK) { LogInfo("failed to hand over the message to IoTHubClient\r\n"); } else { LogInfo("IoTHubClient accepted the message for delivery\r\n"); } IoTHubMessage_Destroy(messageHandle); } free(destination); } } /* wait for commands */ while (1) { IoTHubClient_LL_DoWork(iotHubClientHandle); ThreadAPI_Sleep(100); } } DESTROY_MODEL_INSTANCE(myWeather); } IoTHubClient_LL_Destroy(iotHubClientHandle); } serializer_deinit(); } }
void iothub_messaging_ll_sample_run(void) { xlogging_set_log_function(consolelogger_log); if (platform_init() != 0) { (void)printf("Failed to initialize the platform.\r\n"); } else { (void)printf("Calling IoTHubServiceClientAuth_CreateFromConnectionString with connection string\n"); iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(connectionString); if (iotHubServiceClientHandle == NULL) { (void)printf("IoTHubServiceClientAuth_CreateFromConnectionString failed\n"); } else { (void)printf("Service Client Authentication handle has been created successfully\n"); (void)printf("Creating Messaging...\n"); iotHubMessagingHandle = IoTHubMessaging_LL_Create(iotHubServiceClientHandle); if (iotHubMessagingHandle == NULL) { (void)printf("IoTHubMessaging_LL_Create failed\n"); } else { (void)printf("Messaging has been created successfully\n"); (void)printf("Opening Messaging...\n"); iotHubMessagingResult = IoTHubMessaging_LL_SetFeedbackMessageCallback(iotHubMessagingHandle, feedbackReceivedCallback, "Context string for feedback"); if (iotHubMessagingResult != IOTHUB_MESSAGING_OK) { (void)printf("IoTHubMessaging_LL_SetFeedbackMessageCallback failed\n"); } else { iotHubMessagingResult = IoTHubMessaging_LL_Open(iotHubMessagingHandle, openCompleteCallback, "Context string for open"); if (iotHubMessagingResult != IOTHUB_MESSAGING_OK) { (void)printf("IoTHubMessaging_LL_Open failed\n"); } else { for (int i = 0; i < MESSAGE_COUNT; i++) { double avgWindSpeed = 10.0; static char msgText[1024]; sprintf_s(msgText, sizeof(msgText), "{\"deviceId\":%s,\"windSpeed\":%.2f, \"i\":%d}", deviceId, avgWindSpeed + (rand() % 4 + 2), i); IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText)); if (messageHandle == NULL) { (void)printf("IoTHubMessage_CreateFromByteArray failed\n"); break; } else { iotHubMessagingResult = IoTHubMessaging_LL_Send(iotHubMessagingHandle, deviceId, messageHandle, sendCompleteCallback, NULL); if (iotHubMessagingResult != IOTHUB_MESSAGING_OK) { (void)printf("IoTHubMessaging_LL_Send failed\n"); } else { (void)printf("IoTHubMessaging_LL_Send accepted data for transmission to IoT Hub.\r\n"); } } IoTHubMessage_Destroy(messageHandle); } feedbackCount = 0; while (feedbackCount < MESSAGE_COUNT) { IoTHubMessaging_LL_DoWork(iotHubMessagingHandle); ThreadAPI_Sleep(1); } /* Wait for user to press a key. */ (void)printf("Press any key to exit the application. \r\n"); (void)getchar(); IoTHubMessaging_LL_Close(iotHubMessagingHandle); } } (void)printf("Calling IoTHubMessaging_LL_Destroy...\n"); IoTHubMessaging_LL_Destroy(iotHubMessagingHandle); } (void)printf("Calling IoTHubServiceClientAuth_Destroy...\n"); IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle); } platform_deinit(); } }
void qaas_mqtt_run(char param[]) { int count = 0; char macAdrs[18]; unsigned char* destination; size_t destinationSize; //getMACAddress(0, macAdrs); (void)printf("Mac Adress %s.\r\n", macAdrs); if (platform_init() != 0) { (void)printf("Failed on serializer_init\r\n"); } else { if (serializer_init(NULL) != SERIALIZER_OK) { (void)printf("Failed on serializer_init\r\n"); } else { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, MQTT_Protocol); srand((unsigned int)time(NULL)); int avgPrtclSize = 10; if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_LL_Create\r\n"); } else { CompostClient1* deviceInfo = CREATE_MODEL_INSTANCE(CompostClient, CompostClient1); if (deviceInfo == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, deviceInfo) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { deviceInfo->DeviceId = "CompClnt01"; /* wait for commands */ while (1) { deviceInfo->Height = measuredHeight; if(count%50 == 0) { if (SERIALIZE(&destination, &destinationSize, deviceInfo->DeviceId, deviceInfo->Height) != IOT_AGENT_OK) { (void)printf("Failed to serialize\r\n"); } else { IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(destination, destinationSize); if (messageHandle == NULL) { printf("unable to create a new IoTHubMessage\r\n"); } else { if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messageHandle, sendCallback, (void*)1) != 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(destination); } } IoTHubClient_LL_DoWork(iotHubClientHandle); count++; //ThreadAPI_Sleep(SAMPLES_COUNT * SAMPLING_TIME * 1000); // secs ThreadAPI_Sleep(100); } } DESTROY_MODEL_INSTANCE(deviceInfo); } IoTHubClient_LL_Destroy(iotHubClientHandle); } serializer_deinit(); } platform_deinit(); } }
int main(void) { IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol = MQTT_Protocol; IOTHUB_MESSAGE_HANDLE message_handle; float telemetry_temperature; float telemetry_humidity; const char* telemetry_scale = "Celcius"; char telemetry_msg_buffer[80]; int messagecount = 0; printf("\r\nThis sample will send messages continuously and accept C2D messages.\r\nPress Ctrl+C to terminate the sample.\r\n\r\n"); IOTHUB_DEVICE_CLIENT_HANDLE device_handle; // Used to initialize IoTHub SDK subsystem (void)IoTHub_Init(); (void)printf("Creating IoTHub handle\r\n"); // Create the iothub handle here device_handle = IoTHubDeviceClient_CreateFromConnectionString(connectionString, protocol); if (device_handle == NULL) { (void)printf("Failure creating Iothub device. Hint: Check you connection string.\r\n"); } else { #ifdef SET_TRUSTED_CERT_IN_SAMPLES // Setting the Trusted Certificate. This is only necessary on system with without // built in certificate stores. (void)IoTHubDeviceClient_SetOption(device_handle, OPTION_TRUSTED_CERT, certificates); #endif // SET_TRUSTED_CERT_IN_SAMPLES int i = MESSAGE_COUNT; while(i--) { // Construct the iothub message telemetry_temperature = 20.0f + ((float)rand() / RAND_MAX) * 15.0f; telemetry_humidity = 60.0f + ((float)rand() / RAND_MAX) * 20.0f; sprintf(telemetry_msg_buffer, "{\"temperature\":%.3f,\"humidity\":%.3f,\"scale\":\"%s\"}", telemetry_temperature, telemetry_humidity, telemetry_scale); message_handle = IoTHubMessage_CreateFromString(telemetry_msg_buffer); (void)printf("\r\nSending message %d to IoTHub\r\nMessage: %s\r\n", (int)(messagecount + 1), telemetry_msg_buffer); IoTHubDeviceClient_SendEventAsync(device_handle, message_handle, send_confirm_callback, NULL); // The message is copied to the sdk so the we can destroy it IoTHubMessage_Destroy(message_handle); messagecount = messagecount + 1; ThreadAPI_Sleep(g_interval); } // Clean up the iothub sdk handle IoTHubDeviceClient_Destroy(device_handle); } // Free all the sdk subsystem IoTHub_Deinit(); return 0; }
static void RecvMessage(IOTHUB_PROVISIONED_DEVICE* deviceToUse) { // arrange IOTHUB_CLIENT_HANDLE iotHubClientHandle; IOTHUB_SERVICE_CLIENT_AUTH_HANDLE iotHubServiceClientHandle; IOTHUB_MESSAGING_CLIENT_HANDLE iotHubMessagingHandle; IOTHUB_MESSAGING_RESULT iotHubMessagingResult; IOTHUB_MESSAGE_RESULT iotHubMessageResult; EXPECTED_RECEIVE_DATA* receiveUserContext; IOTHUB_MESSAGE_HANDLE messageHandle; // act IoTHub_Init(); // Create Service Client iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(IoTHubAccount_GetIoTHubConnString(g_iothubAcctInfo1)); ASSERT_IS_NOT_NULL(iotHubServiceClientHandle, "Could not initialize IoTHubServiceClient to send C2D messages to the device"); iotHubMessagingHandle = IoTHubMessaging_Create(iotHubServiceClientHandle); ASSERT_IS_NOT_NULL(iotHubMessagingHandle, "Could not initialize IoTHubMessaging to send C2D messages to the device"); iotHubMessagingResult = IoTHubMessaging_Open(iotHubMessagingHandle, openCompleteCallback, (void*)"Context string for open"); ASSERT_ARE_EQUAL(int, IOTHUB_MESSAGING_OK, iotHubMessagingResult); // Create user context and message receiveUserContext = ReceiveUserContext_Create(); ASSERT_IS_NOT_NULL(receiveUserContext, "Could not create receive user context"); messageHandle = IoTHubMessage_CreateFromString(MSG_CONTENT1); ASSERT_IS_NOT_NULL(messageHandle, "Could not create IoTHubMessage to send C2D messages to the device"); iotHubMessageResult = IoTHubMessage_SetMessageId(messageHandle, MSG_ID1); ASSERT_ARE_EQUAL(int, IOTHUB_MESSAGING_OK, iotHubMessageResult); iotHubMessageResult = IoTHubMessage_SetCorrelationId(messageHandle, MSG_CORRELATION_ID1); ASSERT_ARE_EQUAL(int, IOTHUB_MESSAGING_OK, iotHubMessageResult); MAP_HANDLE mapHandle = IoTHubMessage_Properties(messageHandle); for (size_t i = 0; i < MSG_PROP_COUNT; i++) { if (Map_AddOrUpdate(mapHandle, MSG_PROP_KEYS[i], MSG_PROP_VALS[i]) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate failed for property %zu!\r\n", i); } } iotHubMessagingResult = IoTHubMessaging_SendAsync(iotHubMessagingHandle, deviceToUse->deviceId, messageHandle, sendCompleteCallback, receiveUserContext); ASSERT_ARE_EQUAL(int, IOTHUB_MESSAGING_OK, iotHubMessagingResult, "IoTHubMessaging_SendAsync failed, could not send C2D message to the device"); iotHubClientHandle = IoTHubClient_CreateFromConnectionString(deviceToUse->connectionString, HTTP_Protocol); ASSERT_IS_NOT_NULL(iotHubClientHandle, "Failure creating Iothub Client"); if (deviceToUse->howToCreate == IOTHUB_ACCOUNT_AUTH_X509) { IOTHUB_CLIENT_RESULT result; 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"); } IOTHUB_CLIENT_RESULT result = IoTHubClient_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, receiveUserContext); ASSERT_ARE_EQUAL(IOTHUB_CLIENT_RESULT, IOTHUB_CLIENT_OK, result, "Failure setting message callback"); unsigned int minimumPollingTime = 1; /*because it should not wait*/ if (IoTHubClient_SetOption(iotHubClientHandle, OPTION_MIN_POLLING_TIME, &minimumPollingTime) != IOTHUB_CLIENT_OK) { printf("failure to set option \"MinimumPollingTime\"\r\n"); } time_t beginOperation, nowTime; beginOperation = time(NULL); while ( ( (nowTime = time(NULL)), (difftime(nowTime, beginOperation) < MAX_CLOUD_TRAVEL_TIME) //time box ) ) { if (Lock(receiveUserContext->lock) != LOCK_OK) { ASSERT_FAIL("unable ot lock"); } else { if (receiveUserContext->wasFound) { (void)Unlock(receiveUserContext->lock); break; } (void)Unlock(receiveUserContext->lock); } ThreadAPI_Sleep(100); } // assert ASSERT_IS_TRUE(receiveUserContext->wasFound, "Failure retrieving message that was sent to IotHub."); // was found is written by the callback... // cleanup IoTHubMessage_Destroy(messageHandle); IoTHubMessaging_Close(iotHubMessagingHandle); IoTHubMessaging_Destroy(iotHubMessagingHandle); IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle); IoTHubClient_Destroy(iotHubClientHandle); ReceiveUserContext_Destroy(receiveUserContext); }
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); }
void simplesample_mqtt_run(void) { if (serializer_init(NULL) != SERIALIZER_OK) { (void)printf("Failed on serializer_init\r\n"); } else { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, MQTT_Protocol); srand((unsigned int)time(NULL)); double avgWindSpeed = 10.0; if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_LL_Create\r\n"); } else { ContosoAnemometer* myWeather = CREATE_MODEL_INSTANCE(WeatherStation, ContosoAnemometer); if (myWeather == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, myWeather) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { myWeather->DeviceId = "myFirstDevice"; myWeather->WindSpeed = avgWindSpeed + (rand() % 4 + 2); { unsigned char* destination; size_t destinationSize; if (SERIALIZE(&destination, &destinationSize, myWeather->DeviceId, myWeather->WindSpeed) != IOT_AGENT_OK) { (void)printf("Failed to serialize\r\n"); } else { IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(destination, destinationSize); if (messageHandle == NULL) { printf("unable to create a new IoTHubMessage\r\n"); } else { if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messageHandle, sendCallback, (void*)1) != 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(destination); } } /* wait for commands */ while (1) { IoTHubClient_LL_DoWork(iotHubClientHandle); ThreadAPI_Sleep(100); } } DESTROY_MODEL_INSTANCE(myWeather); } IoTHubClient_LL_Destroy(iotHubClientHandle); } serializer_deinit(); } }
int main(void) { IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol; IOTHUB_MESSAGE_HANDLE message_handle; size_t messages_sent = 0; const char* telemetry_msg = "test_message"; // Select the Protocol to use with the connection #ifdef SAMPLE_MQTT protocol = MQTT_Protocol; #endif // SAMPLE_MQTT #ifdef SAMPLE_MQTT_OVER_WEBSOCKETS protocol = MQTT_WebSocket_Protocol; #endif // SAMPLE_MQTT_OVER_WEBSOCKETS #ifdef SAMPLE_AMQP protocol = AMQP_Protocol; #endif // SAMPLE_AMQP #ifdef SAMPLE_AMQP_OVER_WEBSOCKETS protocol = AMQP_Protocol_over_WebSocketsTls; #endif // SAMPLE_AMQP_OVER_WEBSOCKETS #ifdef SAMPLE_HTTP protocol = HTTP_Protocol; #endif // SAMPLE_HTTP // Used to initialize IoTHub SDK subsystem (void)IoTHub_Init(); IOTHUB_DEVICE_CLIENT_LL_HANDLE device_ll_handle; (void)printf("Creating IoTHub Device handle\r\n"); // Create the iothub handle here device_ll_handle = IoTHubDeviceClient_LL_CreateFromConnectionString(connectionString, protocol); if (device_ll_handle == NULL) { (void)printf("Failure createing Iothub device. Hint: Check you connection string.\r\n"); } else { // Set any option that are neccessary. // For available options please see the iothub_sdk_options.md documentation bool traceOn = true; IoTHubDeviceClient_LL_SetOption(device_ll_handle, OPTION_LOG_TRACE, &traceOn); #ifdef SET_TRUSTED_CERT_IN_SAMPLES // Setting the Trusted Certificate. This is only necessary on system with without // built in certificate stores. IoTHubDeviceClient_LL_SetOption(device_ll_handle, OPTION_TRUSTED_CERT, certificates); #endif // SET_TRUSTED_CERT_IN_SAMPLES #if defined SAMPLE_MQTT || defined SAMPLE_MQTT_WS //Setting the auto URL Encoder (recommended for MQTT). Please use this option unless //you are URL Encoding inputs yourself. //ONLY valid for use with MQTT //bool urlEncodeOn = true; //IoTHubDeviceClient_LL_SetOption(iothub_ll_handle, OPTION_AUTO_URL_ENCODE_DECODE, &urlEncodeOn); #endif // Setting connection status callback to get indication of connection to iothub (void)IoTHubDeviceClient_LL_SetConnectionStatusCallback(device_ll_handle, connection_status_callback, NULL); do { if (messages_sent < MESSAGE_COUNT) { // Construct the iothub message from a string or a byte array message_handle = IoTHubMessage_CreateFromString(telemetry_msg); //message_handle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText))); // Set Message property /*(void)IoTHubMessage_SetMessageId(message_handle, "MSG_ID"); (void)IoTHubMessage_SetCorrelationId(message_handle, "CORE_ID"); (void)IoTHubMessage_SetContentTypeSystemProperty(message_handle, "application%2fjson"); (void)IoTHubMessage_SetContentEncodingSystemProperty(message_handle, "utf-8");*/ // Add custom properties to message (void)IoTHubMessage_SetProperty(message_handle, "property_key", "property_value"); (void)printf("Sending message %d to IoTHub\r\n", (int)(messages_sent + 1)); IoTHubDeviceClient_LL_SendEventAsync(device_ll_handle, message_handle, send_confirm_callback, NULL); // The message is copied to the sdk so the we can destroy it IoTHubMessage_Destroy(message_handle); messages_sent++; } else if (g_message_count_send_confirmations >= MESSAGE_COUNT) { // After all messages are all received stop running g_continueRunning = false; } IoTHubDeviceClient_LL_DoWork(device_ll_handle); ThreadAPI_Sleep(1); } while (g_continueRunning); // Clean up the iothub sdk handle IoTHubDeviceClient_LL_Destroy(device_ll_handle); } // Free all the sdk subsystem IoTHub_Deinit(); printf("Press any key to continue"); getchar(); return 0; }
int main(void) { IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol; IOTHUB_MESSAGE_HANDLE message_handle; const char* telemetry_msg = "test_message"; char *cert_string = NULL; printf("This sample will send %d messages and wait for any C2D messages.\r\nPress the enter key to end the sample\r\n\r\n", MESSAGE_COUNT); // Select the Protocol to use with the connection #ifdef SAMPLE_MQTT protocol = MQTT_Protocol; #endif // SAMPLE_MQTT #ifdef SAMPLE_MQTT_OVER_WEBSOCKETS protocol = MQTT_WebSocket_Protocol; #endif // SAMPLE_MQTT_OVER_WEBSOCKETS #ifdef SAMPLE_AMQP protocol = AMQP_Protocol; #endif // SAMPLE_AMQP #ifdef SAMPLE_AMQP_OVER_WEBSOCKETS protocol = AMQP_Protocol_over_WebSocketsTls; #endif // SAMPLE_AMQP_OVER_WEBSOCKETS #ifdef SAMPLE_HTTP protocol = HTTP_Protocol; #endif // SAMPLE_HTTP IOTHUB_DEVICE_CLIENT_HANDLE device_handle; // Used to initialize IoTHub SDK subsystem (void)IoTHub_Init(); (void)printf("Creating IoTHub handle\r\n"); // Create the iothub handle here device_handle = IoTHubDeviceClient_CreateFromConnectionString(connectionString, protocol); if (device_handle == NULL) { (void)printf("Failure creating device client handle. Hint: Check you connection string.\r\n"); } else { // Setting message callback to get C2D messages (void)IoTHubDeviceClient_SetMessageCallback(device_handle, receive_msg_callback, NULL); // Setting connection status callback to get indication of connection to iothub (void)IoTHubDeviceClient_SetConnectionStatusCallback(device_handle, connection_status_callback, NULL); // Set any option that are necessary. // For available options please see the iothub_sdk_options.md documentation // Turn tracing on/off // bool traceOn = true; // (void)IoTHubDeviceClient_SetOption(device_handle, OPTION_LOG_TRACE, &traceOn); // Provide the Azure IoT device client with the Edge root // X509 CA certificate that was used to setup the Edge runtime cert_string = obtain_edge_ca_certificate(); (void)IoTHubDeviceClient_SetOption(device_handle, OPTION_TRUSTED_CERT, cert_string); #if defined SAMPLE_MQTT || defined SAMPLE_MQTT_OVER_WEBSOCKETS //Setting the auto URL Encoder (recommended for MQTT). Please use this option unless //you are URL Encoding inputs yourself. //ONLY valid for use with MQTT //bool urlEncodeOn = true; //(void)IoTHubDeviceClient_SetOption(device_handle, OPTION_AUTO_URL_ENCODE_DECODE, &urlEncodeOn); #endif for (size_t index = 0; index < MESSAGE_COUNT; index++) { // Construct the iothub message from a string message_handle = IoTHubMessage_CreateFromString(telemetry_msg); // Set Message property (void)IoTHubMessage_SetMessageId(message_handle, "MSG_ID"); (void)IoTHubMessage_SetCorrelationId(message_handle, "CORE_ID"); (void)IoTHubMessage_SetContentTypeSystemProperty(message_handle, "application%2fjson"); (void)IoTHubMessage_SetContentEncodingSystemProperty(message_handle, "utf-8"); // Add custom properties to message (void)IoTHubMessage_SetProperty(message_handle, "property_key", "property_value"); (void)printf("Sending message %d to Edge Hub\r\n", (int)(index + 1)); IoTHubDeviceClient_SendEventAsync(device_handle, message_handle, send_confirm_callback, NULL); // The message is copied to the sdk so the we can destroy it IoTHubMessage_Destroy(message_handle); } printf("\r\nPress any key to continue\r\n"); (void)getchar(); // Clean up the iothub sdk handle IoTHubDeviceClient_Destroy(device_handle); if (cert_string != NULL) { free(cert_string); cert_string = NULL; } } // Free all the sdk subsystem IoTHub_Deinit(); return 0; }
void iothub_client_sample_amqp_run(void) { TRANSPORT_HANDLE transport_handle; IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle1; IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle2; EVENT_INSTANCE messages_device1[MESSAGE_COUNT]; EVENT_INSTANCE messages_device2[MESSAGE_COUNT]; g_continueRunning = true; //callbackCounter = 0; int receiveContext1 = 0; int receiveContext2 = 0; (void)printf("Starting the IoTHub client sample AMQP...\r\n"); if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { if ((transport_handle = IoTHubTransport_Create(AMQP_Protocol, hubName, hubSuffix)) == NULL) { printf("Failed to creating the protocol handle.\r\n"); } else { IOTHUB_CLIENT_DEVICE_CONFIG config1; config1.deviceId = deviceId1; config1.deviceKey = deviceKey1; config1.deviceSasToken = NULL; config1.protocol = AMQP_Protocol; config1.transportHandle = IoTHubTransport_GetLLTransport(transport_handle); IOTHUB_CLIENT_DEVICE_CONFIG config2; config2.deviceId = deviceId2; config2.deviceKey = deviceKey2; config2.deviceSasToken = NULL; config2.protocol = AMQP_Protocol; config2.transportHandle = IoTHubTransport_GetLLTransport(transport_handle); if ((iotHubClientHandle1 = IoTHubClient_LL_CreateWithTransport(&config1)) == NULL) { (void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n"); } else if ((iotHubClientHandle2 = IoTHubClient_LL_CreateWithTransport(&config2)) == NULL) { (void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n"); } else { bool traceOn = true; IoTHubClient_LL_SetOption(iotHubClientHandle1, OPTION_LOG_TRACE, &traceOn); #ifdef SET_TRUSTED_CERT_IN_SAMPLES // For mbed add the certificate information if (IoTHubClient_LL_SetOption(iotHubClientHandle1, OPTION_TRUSTED_CERT, certificates) != IOTHUB_CLIENT_OK) { printf("failure to set option \"TrustedCerts\"\r\n"); } #endif // SET_TRUSTED_CERT_IN_SAMPLES if (create_events(messages_device1, config1.deviceId) != 0 || create_events(messages_device2, config2.deviceId) != 0) { (void)printf("ERROR: failed creating events for the devices..........FAILED!\r\n"); } /* Setting Message call back, so we can receive Commands. */ else if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle1, ReceiveMessageCallback, &receiveContext1) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SetMessageCallback for device 1..........FAILED!\r\n"); } else if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle2, ReceiveMessageCallback, &receiveContext2) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SetMessageCallback for device 2..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SetMessageCallback...successful.\r\n"); /* Now that we are ready to receive commands, let's send some messages */ size_t iterator = 0; do { if (iterator < MESSAGE_COUNT) { if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle1, messages_device1[iterator].messageHandle, SendConfirmationCallback, &messages_device1[iterator]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SendEventAsync for device 1..........FAILED!\r\n"); } else if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle2, messages_device2[iterator].messageHandle, SendConfirmationCallback, &messages_device2[iterator]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SendEventAsync for device 2..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SendEventAsync accepted data for transmission to IoT Hub.\r\n"); } IoTHubMessage_Destroy(messages_device1[iterator].messageHandle); IoTHubMessage_Destroy(messages_device2[iterator].messageHandle); } IoTHubClient_LL_DoWork(iotHubClientHandle1); IoTHubClient_LL_DoWork(iotHubClientHandle2); ThreadAPI_Sleep(1); iterator++; } while (g_continueRunning); (void)printf("iothub_client_sample_mqtt has gotten quit message, call DoWork %d more time to complete final sending...\r\n", DOWORK_LOOP_NUM); for (size_t index = 0; index < DOWORK_LOOP_NUM; index++) { IoTHubClient_LL_DoWork(iotHubClientHandle1); ThreadAPI_Sleep(1); } } IoTHubClient_LL_Destroy(iotHubClientHandle1); IoTHubClient_LL_Destroy(iotHubClientHandle2); } IoTHubTransport_Destroy(transport_handle); } platform_deinit(); } }
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_messaging_ll_sample_run(void) { xlogging_set_log_function(consolelogger_log); if (platform_init() != 0) { (void)printf("Failed to initialize the platform.\r\n"); } else { (void)printf("Calling IoTHubServiceClientAuth_CreateFromConnectionString with connection string\n"); iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(connectionString); if (iotHubServiceClientHandle == NULL) { (void)printf("IoTHubServiceClientAuth_CreateFromConnectionString failed\n"); } else { (void)printf("Service Client Authentication handle has been created successfully\n"); (void)printf("Creating Messaging...\n"); iotHubMessagingHandle = IoTHubMessaging_LL_Create(iotHubServiceClientHandle); if (iotHubMessagingHandle == NULL) { (void)printf("IoTHubMessaging_LL_Create failed\n"); } else { (void)printf("Messaging has been created successfully\n"); (void)printf("Opening Messaging...\n"); iotHubMessagingResult = IoTHubMessaging_LL_SetFeedbackMessageCallback(iotHubMessagingHandle, feedbackReceivedCallback, "Context string for feedback"); if (iotHubMessagingResult != IOTHUB_MESSAGING_OK) { (void)printf("IoTHubMessaging_LL_SetFeedbackMessageCallback failed\n"); } else { iotHubMessagingResult = IoTHubMessaging_LL_Open(iotHubMessagingHandle, openCompleteCallback, "Context string for open"); if (iotHubMessagingResult != IOTHUB_MESSAGING_OK) { (void)printf("IoTHubMessaging_LL_Open failed\n"); } else { for (int i = 0; i < MESSAGE_COUNT; i++) { double avgWindSpeed = 10.0; static char msgText[1024]; sprintf_s(msgText, sizeof(msgText), "{\"deviceId\":%s,\"windSpeed\":%.2f, \"i\":%d}", deviceId, avgWindSpeed + (rand() % 4 + 2), i); IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText)); if (messageHandle == NULL) { (void)printf("IoTHubMessage_CreateFromByteArray failed\n"); break; } else { IOTHUB_MESSAGE_RESULT iotHubMessageResult; const char* MSG_ID = "Sample_MessageId"; const char* MSG_CORRELATION_ID = "Sample_MessageCorrelationId"; const char* MSG_PROP_KEYS[3] = { "Sample_Key1", "Sample_Key2", "Sample_Key3" }; const char* MSG_PROP_VALS[3] = { "Sample_Val1", "Sample_Val2", "Sample_Val3" }; iotHubMessageResult = IoTHubMessage_SetMessageId(messageHandle, MSG_ID); if (iotHubMessageResult != IOTHUB_MESSAGE_OK) { (void)printf("IoTHubMessage_SetMessageId failed. Exiting...\n"); IoTHubMessage_Destroy(messageHandle); break; } else { iotHubMessageResult = IoTHubMessage_SetCorrelationId(messageHandle, MSG_CORRELATION_ID); if (iotHubMessageResult != IOTHUB_MESSAGE_OK) { (void)printf("IoTHubMessage_SetCorrelationId failed. Exiting...\n"); IoTHubMessage_Destroy(messageHandle); break; } else { MAP_HANDLE mapHandle = IoTHubMessage_Properties(messageHandle); for (size_t j = 0; j < 3; j++) { if (Map_AddOrUpdate(mapHandle, MSG_PROP_KEYS[j], MSG_PROP_VALS[j]) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate failed for property %zu!\r\n", j); } } iotHubMessagingResult = IoTHubMessaging_LL_Send(iotHubMessagingHandle, deviceId, messageHandle, sendCompleteCallback, NULL); if (iotHubMessagingResult != IOTHUB_MESSAGING_OK) { (void)printf("IoTHubMessaging_LL_Send failed\n"); } else { (void)printf("IoTHubMessaging_LL_Send accepted data for transmission to IoT Hub.\r\n"); } } } } IoTHubMessage_Destroy(messageHandle); } feedbackCount = 0; while (feedbackCount < MESSAGE_COUNT) { IoTHubMessaging_LL_DoWork(iotHubMessagingHandle); ThreadAPI_Sleep(1); } /* Wait for user to press a key. */ (void)printf("Press any key to exit the application. \r\n"); (void)getchar(); IoTHubMessaging_LL_Close(iotHubMessagingHandle); } } (void)printf("Calling IoTHubMessaging_LL_Destroy...\n"); IoTHubMessaging_LL_Destroy(iotHubMessagingHandle); } (void)printf("Calling IoTHubServiceClientAuth_Destroy...\n"); IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle); } platform_deinit(); } }
int main(void) { TRANSPORT_HANDLE transport_handle; IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol; IOTHUB_DEVICE_CLIENT_LL_HANDLE device_ll_handle1; IOTHUB_DEVICE_CLIENT_LL_HANDLE device_ll_handle2; #ifdef SAMPLE_AMQP protocol = AMQP_Protocol; #endif // SAMPLE_AMQP #ifdef SAMPLE_AMQP_OVER_WEBSOCKETS protocol = AMQP_Protocol_over_WebSocketsTls; #endif // SAMPLE_AMQP_OVER_WEBSOCKETS #ifdef SAMPLE_HTTP protocol = HTTP_Protocol; #endif // SAMPLE_HTTP g_continueRunning = true; //callbackCounter = 0; int receiveContext1 = 0; int receiveContext2 = 0; (void)printf("Starting the IoTHub client shared sample. Send `quit` message to either device to close...\r\n"); // Used to initialize IoTHub SDK subsystem (void)IoTHub_Init(); if ((transport_handle = IoTHubTransport_Create(protocol, hubName, hubSuffix)) == NULL) { printf("Failed to creating the protocol handle.\r\n"); } else { EVENT_INSTANCE device1_event; EVENT_INSTANCE device2_event; device1_event.deviceId = deviceId1; IOTHUB_CLIENT_DEVICE_CONFIG config1 = { 0 }; config1.deviceId = deviceId1; config1.deviceKey = deviceKey1; config1.deviceSasToken = NULL; config1.protocol = protocol; config1.transportHandle = IoTHubTransport_GetLLTransport(transport_handle); device2_event.deviceId = deviceId2; IOTHUB_CLIENT_DEVICE_CONFIG config2 = { 0 }; config2.deviceId = deviceId2; config2.deviceKey = deviceKey2; config2.deviceSasToken = NULL; config2.protocol = protocol; config2.transportHandle = IoTHubTransport_GetLLTransport(transport_handle); if ((device_ll_handle1 = IoTHubDeviceClient_LL_CreateWithTransport(&config1)) == NULL) { (void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n"); } else if ((device_ll_handle2 = IoTHubDeviceClient_LL_CreateWithTransport(&config2)) == NULL) { (void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n"); } else { // Set any option that are neccessary. // For available options please see the iothub_sdk_options.md documentation //bool traceOn = true; //IoTHubDeviceClient_LL_SetOption(device_ll_handle1, OPTION_LOG_TRACE, &traceOn); //IoTHubDeviceClient_LL_SetOption(device_ll_handle2, OPTION_LOG_TRACE, &traceOn); #ifdef SET_TRUSTED_CERT_IN_SAMPLES // Setting the Trusted Certificate. This is only necessary on system without // built in certificate stores. IoTHubDeviceClient_LL_SetOption(device_ll_handle1, OPTION_TRUSTED_CERT, certificates); IoTHubDeviceClient_LL_SetOption(device_ll_handle2, OPTION_TRUSTED_CERT, certificates); #endif // SET_TRUSTED_CERT_IN_SAMPLES #ifdef SAMPLE_HTTP unsigned int timeout = 241000; // Because it can poll "after 9 seconds" polls will happen effectively // at ~10 seconds. // Note that for scalabilty, the default value of minimumPollingTime // is 25 minutes. For more information, see: // https://azure.microsoft.com/documentation/articles/iot-hub-devguide/#messaging unsigned int minimumPollingTime = 9; IoTHubDeviceClient_LL_SetOption(device_ll_handle1, OPTION_MIN_POLLING_TIME, &minimumPollingTime); IoTHubDeviceClient_LL_SetOption(device_ll_handle1, OPTION_HTTP_TIMEOUT, &timeout); IoTHubDeviceClient_LL_SetOption(device_ll_handle2, OPTION_MIN_POLLING_TIME, &minimumPollingTime); IoTHubDeviceClient_LL_SetOption(device_ll_handle2, OPTION_HTTP_TIMEOUT, &timeout); #endif // SAMPLE_HTTP /* Setting Message call back, so we can receive Commands. */ (void)IoTHubDeviceClient_LL_SetMessageCallback(device_ll_handle1, ReceiveMessageCallback, &receiveContext1); (void)IoTHubDeviceClient_LL_SetMessageCallback(device_ll_handle2, ReceiveMessageCallback, &receiveContext2); /* Now that we are ready to receive commands, let's send some messages */ size_t messages_sent = 0; IOTHUB_MESSAGE_HANDLE message_handle; do { if (messages_sent < MESSAGE_COUNT) { // Create the event hub message message_handle = create_events(&device1_event); (void)IoTHubDeviceClient_LL_SendEventAsync(device_ll_handle1, message_handle, SendConfirmationCallback, &device1_event); // The message is copied to the sdk so the we can destroy it IoTHubMessage_Destroy(message_handle); message_handle = create_events(&device2_event); (void)IoTHubDeviceClient_LL_SendEventAsync(device_ll_handle2, message_handle, SendConfirmationCallback, &device2_event); // The message is copied to the sdk so the we can destroy it IoTHubMessage_Destroy(message_handle); messages_sent++; } IoTHubDeviceClient_LL_DoWork(device_ll_handle1); IoTHubDeviceClient_LL_DoWork(device_ll_handle2); ThreadAPI_Sleep(1); } while (g_continueRunning); (void)printf("client_amqp_shared_sample has gotten quit message, call DoWork %d more time to complete final sending...\r\n", DOWORK_LOOP_NUM); for (size_t index = 0; index < DOWORK_LOOP_NUM; index++) { IoTHubDeviceClient_LL_DoWork(device_ll_handle1); IoTHubDeviceClient_LL_DoWork(device_ll_handle2); ThreadAPI_Sleep(1); } // Clean up the iothub sdk handle IoTHubDeviceClient_LL_Destroy(device_ll_handle1); IoTHubDeviceClient_LL_Destroy(device_ll_handle2); } IoTHubTransport_Destroy(transport_handle); // Free all the sdk subsystem IoTHub_Deinit(); } return 0; }
void simplesample_http_run(void) { if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { if (serializer_init(NULL) != SERIALIZER_OK) { (void)printf("Failed on serializer_init\r\n"); } else { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, HTTP_Protocol); int avgWindSpeed = 10; srand((unsigned int)time(NULL)); if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_LL_Create\r\n"); } else { // Because it can poll "after 9 seconds" polls will happen // effectively at ~10 seconds. // Note that for scalabilty, the default value of minimumPollingTime // is 25 minutes. For more information, see: // https://azure.microsoft.com/documentation/articles/iot-hub-devguide/#messaging unsigned int minimumPollingTime = 9; ContosoAnemometer* myWeather; if (IoTHubClient_LL_SetOption(iotHubClientHandle, "MinimumPollingTime", &minimumPollingTime) != IOTHUB_CLIENT_OK) { printf("failure to set option \"MinimumPollingTime\"\r\n"); } #ifdef MBED_BUILD_TIMESTAMP // For mbed add the certificate information if (IoTHubClient_LL_SetOption(iotHubClientHandle, "TrustedCerts", certificates) != IOTHUB_CLIENT_OK) { (void)printf("failure to set option \"TrustedCerts\"\r\n"); } #endif // MBED_BUILD_TIMESTAMP myWeather = CREATE_MODEL_INSTANCE(WeatherStation, ContosoAnemometer); if (myWeather == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, myWeather) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { myWeather->DeviceId = "myFirstDevice"; myWeather->WindSpeed = avgWindSpeed + (rand() % 4 + 2); { unsigned char* destination; size_t destinationSize; if (SERIALIZE(&destination, &destinationSize, myWeather->DeviceId, myWeather->WindSpeed) != CODEFIRST_OK) { (void)printf("Failed to serialize\r\n"); } else { IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(destination, destinationSize); if (messageHandle == NULL) { printf("unable to create a new IoTHubMessage\r\n"); } else { if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messageHandle, sendCallback, (void*)1) != 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(destination); } } /* wait for commands */ while (1) { IoTHubClient_LL_DoWork(iotHubClientHandle); ThreadAPI_Sleep(100); } } DESTROY_MODEL_INSTANCE(myWeather); } IoTHubClient_LL_Destroy(iotHubClientHandle); } serializer_deinit(); } platform_deinit(); } }