int main(void) { TRANSPORT_HANDLE transport_handle; IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol; IOTHUB_DEVICE_CLIENT_HANDLE device_handle1; IOTHUB_DEVICE_CLIENT_HANDLE device_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 (void)printf("Starting the IoTHub client sample C2D methods on AMQP over WebSockets with multiplexing ...\r\n"); // Used to initialize IoTHub SDK subsystem (void)IoTHub_Init(); if ((transport_handle = IoTHubTransport_Create(protocol, hubName, hubSuffix)) == NULL) { (void)printf("Failed to creating the protocol handle.\r\n"); } else { IOTHUB_CLIENT_CONFIG client_config1; client_config1.deviceId = deviceId1; client_config1.deviceKey = deviceKey1; client_config1.deviceSasToken = NULL; client_config1.iotHubName = hubName; client_config1.iotHubSuffix = hubSuffix; client_config1.protocol = protocol; client_config1.protocolGatewayHostName = NULL; IOTHUB_CLIENT_CONFIG client_config2; client_config2.deviceId = deviceId2; client_config2.deviceKey = deviceKey2; client_config2.deviceSasToken = NULL; client_config2.iotHubName = hubName; client_config2.iotHubSuffix = hubSuffix; client_config2.protocol = protocol; client_config2.protocolGatewayHostName = NULL; if ((device_handle1 = IoTHubDeviceClient_CreateWithTransport(transport_handle, &client_config1)) == NULL) { (void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n"); } else if ((device_handle2 = IoTHubDeviceClient_CreateWithTransport(transport_handle, &client_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_SetOption(device_handle1, OPTION_LOG_TRACE, &traceOn); //IoTHubDeviceClient_SetOption(device_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_SetOption(device_handle1, OPTION_TRUSTED_CERT, certificates); IoTHubDeviceClient_SetOption(device_handle2, OPTION_TRUSTED_CERT, certificates); #endif // SET_TRUSTED_CERT_IN_SAMPLES /* Here subscribe for C2D methods */ if (IoTHubDeviceClient_SetDeviceMethodCallback(device_handle1, DeviceMethodCallback, (void*)deviceId1) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SetDeviceMethodCallback for the first device..........FAILED!\r\n"); } else if (IoTHubDeviceClient_SetDeviceMethodCallback(device_handle2, DeviceMethodCallback, (void*)deviceId2) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SetDeviceMethodCallback for the second device..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SetMessageCallback...successful.\r\n"); (void)printf("Waiting for C2D methods ...\r\n"); (void)printf("Press enter to close application\r\n"); (void)getchar(); } // Clean up the iothub sdk handle IoTHubDeviceClient_Destroy(device_handle1); IoTHubDeviceClient_Destroy(device_handle2); } IoTHubTransport_Destroy(transport_handle); // Free all the sdk subsystem IoTHub_Deinit(); } return 0; }
void iothub_client_sample_http_run(void) { TRANSPORT_HANDLE httpTransport; IOTHUB_CLIENT_HANDLE iothubClient1; IOTHUB_CLIENT_HANDLE iothubClient2; EVENT_INSTANCE messages1[MESSAGE_COUNT]; EVENT_INSTANCE messages2[MESSAGE_COUNT]; double avgWindSpeed = 10.0; double minTemperature = 20.0; double minHumidity = 60.0; double temperature = 0; double humidity = 0; int receiveContext1 = 0; int receiveContext2 = 0; srand((unsigned int)time(NULL)); callbackCounter = 0; if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { (void)printf("Starting the IoTHub client sample HTTP with Shared connection...\r\n"); if ((httpTransport = IoTHubTransport_Create(HTTP_Protocol, hubName, hubSuffix)) == NULL) { (void)printf("ERROR: httpTransport is NULL\r\n"); } else { IOTHUB_CLIENT_CONFIG config1; config1.deviceId = deviceId1; config1.deviceKey = deviceKey1; config1.protocol = HTTP_Protocol; config1.iotHubName = NULL; config1.iotHubSuffix = NULL; config1.deviceSasToken = NULL; if ((iothubClient1 = IoTHubClient_CreateWithTransport(httpTransport, &config1)) == NULL) { (void)printf("ERROR: 1st device handle is NULL\r\n"); } else { IOTHUB_CLIENT_CONFIG config2; config2.deviceId = deviceId2; config2.deviceKey = deviceKey2; config2.protocol = HTTP_Protocol; config2.iotHubName = NULL; config2.iotHubSuffix = NULL; config2.deviceSasToken = NULL; if ((iothubClient2 = IoTHubClient_CreateWithTransport(httpTransport, &config2)) == NULL) { (void)printf("ERROR: 2nd device handle is NULL\r\n"); } else { 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; iothub_client_sample_http_setoptions(iothubClient1, timeout, minimumPollingTime); iothub_client_sample_http_setoptions(iothubClient2, timeout, minimumPollingTime); // Setting message callbacks so we can receive commands if (IoTHubClient_SetMessageCallback(iothubClient1, ReceiveMessageCallback, &receiveContext1) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SetMessageCallback 1st device..........FAILED!\r\n"); } else { if (IoTHubClient_SetMessageCallback(iothubClient2, ReceiveMessageCallback, &receiveContext2) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SetMessageCallback 2nd device..........FAILED!\r\n"); } else { // Now that we are ready to receive commands, let's send some messages int i; (void)printf("IoTHubClient_LL_SetMessageCallback...successful.\r\n"); for (i = 0; i < MESSAGE_COUNT; i++) { temperature = minTemperature + (rand() % 10); humidity = minHumidity + (rand() % 20); sprintf_s(msgText, sizeof(msgText), "{\"deviceId\": \"%s\",\"windSpeed\":%.2f,\"temperature\":%.2f,\"humidity\":%.2f}", deviceId1, avgWindSpeed + (rand() % 4 + 2), temperature, humidity); iothub_client_sample_http_send_one_msg(iothubClient1, &messages1[i], i); temperature = minTemperature + (rand() % 10); humidity = minHumidity + (rand() % 20); sprintf_s(msgText, sizeof(msgText), "{\"deviceId\": \"%s\",\"windSpeed\":%.2f,\"temperature\":%.2f,\"humidity\":%.2f}", deviceId2, avgWindSpeed + (rand() % 4 + 2), temperature, humidity); iothub_client_sample_http_send_one_msg(iothubClient2, &messages2[i], i); } // Wait for any incoming messages (void)printf("Press any key to exit the application. \r\n"); (void)getchar(); } } IoTHubClient_Destroy(iothubClient2); } IoTHubClient_Destroy(iothubClient1); } IoTHubTransport_Destroy(httpTransport); } platform_deinit(); } }
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(); } }
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; }