Void Ducati_AppTask (UArg arg1, UArg arg2) { FCSettings_init(); Diags_setMask(FCSETTINGS_MODNAME"+12345678LEXAIZFS"); CESettings_init(); Diags_setMask(CESETTINGS_MODNAME"+12345678LEXAIZFS"); // Diags_setMask("ti.sdo.rcm.RcmServer-12"); // Diags_setMask("ti.sysbios.utils.Load-4"); init_IVAHDFrwk(); HDVICP_Reset(NULL, NULL); platform_init(); /* how do we know when to unload.. */ while (1) { Task_sleep(0x7fffffff); } /*The test cases will run in this task's context in the init call. Once init returns, testcases have exited so do deinit*/ platform_deinit(); exit_IVAHDFrwk(); System_exit(0); }
void receive_cloud_to_device_message() { if (platform_init() != 0) { printf("Failed initializing platform.\r\n"); return; } 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::promise<void> completion; if (IoTHubClient_SetMessageCallback(iothub_client_handle, receive_callback, &completion) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } completion.get_future().wait(); IoTHubClient_Destroy(iothub_client_handle); } platform_deinit(); }
Void Dsp_AppTask (UArg arg1, UArg arg2) { OMX_ERRORTYPE eError = OMX_ErrorNone; //TIMM_OSAL_ERRORTYPE osalError = TIMM_OSAL_ERR_NONE; /*--------------------------------------------------------------------------*/ /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ /* Initiailize the system. The initialization can include driver, syslink */ /* cache. */ /*--------------------------------------------------------------------------*/ Log_print0 (Diags_USER1,"DSP: In Dsp_AppTask"); platform_init (); Log_print0 (Diags_USER1,"DSP: Platform Initialized"); while (TRUE) { Task_sleep (DSP_APP_TASK_SLEEP_DURATION); } /*--------------------------------------------------------------------------*/ /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ /* UnInitiailize the system. */ /*--------------------------------------------------------------------------*/ platform_deinit (); Log_print0 (Diags_USER1,"DSP: Platform De-Initialized"); Log_print0 (Diags_USER1,"DSP: Exiting the system"); System_exit (0); //EXIT: if (eError != OMX_ErrorNone) { Log_print1 (Diags_USER1,"Error in executing app. Failed code:%d", eError); } } /* Dsp_AppTask */
int main(int argc, char* argv[]) { size_t seconds = TEST_SECONDS; METRIC_AZURE_INFO metric_info; process_arguments(argc, (const char**)argv, &metric_info); if (platform_init() == 0) { gballoc_init(); if (ExecuteIotHubTest(&metric_info, seconds) != 0) { (void)printf("Mqtt run failed\r\n"); } gballoc_deinit(); platform_deinit(); } else { (void)printf("Platform_Init Failed\r\n"); } (void)printf("Press any key to exit: "); (int)getchar(); return 0; }
void mqtt_client_sample_run() { if (platform_init() != 0) { PrintLogFunction(LOG_LINE, "platform_init failed"); } else { MQTT_CLIENT_HANDLE mqttHandle = mqtt_client_init(OnRecvCallback, OnOperationComplete, NULL, PrintLogFunction); if (mqttHandle == NULL) { PrintLogFunction(LOG_LINE, "mqtt_client_init failed"); } else { MQTT_CLIENT_OPTIONS options = { 0 }; options.clientId = "azureiotclient"; options.willMessage = NULL; options.username = NULL; options.password = NULL; options.keepAliveInterval = 10; options.useCleanSession = true; options.qualityOfServiceValue = DELIVER_AT_MOST_ONCE; SOCKETIO_CONFIG config = {"test.mosquitto.org", PORT_NUM_UNENCRYPTED, NULL}; XIO_HANDLE xio = xio_create(socketio_get_interface_description(), &config, PrintLogFunction); if (xio == NULL) { PrintLogFunction(LOG_LINE, "xio_create failed"); } else { if (mqtt_client_connect(mqttHandle, xio, &options) != 0) { PrintLogFunction(LOG_LINE, "mqtt_client_connect failed"); } else { do { mqtt_client_dowork(mqttHandle); } while (g_continue); } xio_close(xio, OnCloseComplete, NULL); } mqtt_client_deinit(mqttHandle); } platform_deinit(); } #ifdef _CRT_DBG_MAP_ALLOC _CrtDumpMemoryLeaks(); #endif }
void raspberrypi_photoupload_run(void) { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle; time_t now; struct tm *local; char* photoFileName; const unsigned char* photoContent; long contentLength; if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { (void)printf("Starting the IoTHub client sample upload to blob...\r\n"); if ((iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, HTTP_Protocol)) == NULL) { (void)printf("ERROR: iotHubClientHandle is NULL!\r\n"); } else { printf("Connected to IoT Hub\r\n"); while (true) { photoContent = take_photo(&contentLength); if (photoContent != NULL) { now = time(NULL); local = localtime(&now); photoFileName = (char*)malloc(strlen(deviceId) + 32); sprintf(photoFileName, "%s_%04d_%02d_%02d_%02d_%02d_%02d_Pro.jpg", deviceId, local->tm_year+1900, local->tm_mon+1, local->tm_mday, local->tm_hour, local->tm_min, local->tm_sec); printf("Try to upload as %s size is %d\r\n", photoFileName, contentLength); if (IoTHubClient_LL_UploadToBlob(iotHubClientHandle, photoFileName, photoContent, contentLength) != IOTHUB_CLIENT_OK) { printf("Failed to upload picture\r\n"); } else { printf("Uploaded %s %d bytes.\r\n", photoFileName, contentLength); } free((void*)photoFileName); free((void*)photoContent); } else { printf("Failed to take a picture\r\n"); } sleep(duration); } IoTHubClient_LL_Destroy(iotHubClientHandle); } platform_deinit(); } }
int main(void) { (void)platform_init(); (void)printf("Calling IoTHubServiceClientAuth_CreateFromConnectionString with connectionString\n"); IOTHUB_SERVICE_CLIENT_AUTH_HANDLE iotHubServiceClientHandle = IoTHubServiceClientAuth_CreateFromConnectionString(connectionString); if (iotHubServiceClientHandle == NULL) { (void)printf("IoTHubServiceClientAuth_CreateFromConnectionString failed\n"); } else { IOTHUB_SERVICE_CLIENT_DEVICE_METHOD_HANDLE serviceClientDeviceMethodHandle = IoTHubDeviceMethod_Create(iotHubServiceClientHandle); if (serviceClientDeviceMethodHandle == NULL) { (void)printf("IoTHubDeviceMethod_Create failed\n"); } else { (void)printf("Invoking method %s on device...\n", methodName); int responseStatus; unsigned char* responsePayload; size_t responsePayloadSize; IOTHUB_DEVICE_METHOD_RESULT invokeResult = IoTHubDeviceMethod_Invoke(serviceClientDeviceMethodHandle, deviceId, methodName, methodPayload, timeout, &responseStatus, &responsePayload, &responsePayloadSize); if (invokeResult == IOTHUB_DEVICE_METHOD_OK) { printf("\r\nDevice Method called\r\n"); printf("Device Method name: %s\r\n", methodName); printf("Device Method payload: %s\r\n", methodPayload); printf("\r\nResponse status: %d\r\n", responseStatus); printf("Response payload: %.*s\r\n", (int)responsePayloadSize, (const char*)responsePayload); free(responsePayload); } else { (void)printf("IoTHubDeviceMethod_Invoke failed with result: %d\n", invokeResult); } (void)printf("Calling IoTHubDeviceMethod_Destroy...\n"); IoTHubDeviceMethod_Destroy(serviceClientDeviceMethodHandle); } (void)printf("Calling IoTHubServiceClientAuth_Destroy...\n"); IoTHubServiceClientAuth_Destroy(iotHubServiceClientHandle); } platform_deinit(); }
int main(void) { int result; (void)printf("Initializing mbed specific things...\r\n"); if ((result = platform_init()) != 0) { (void)printf("Error initializing the platform: %d\r\n",result); return -1; } simplesample_http_run(); platform_deinit(); return 0; }
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(); }
int main(int argc, char*argv[]) { // create glib loop and register a ctrl+c handler GMainLoop* loop = g_main_loop_new(NULL, FALSE); handle_control_c(loop); int result; if (validate_args(argc, argv) == false) { result = 1; } else { if(platform_init() == 0) { char *json_path = argv[1]; GATEWAY_HANDLE gateway = Gateway_CreateFromJson(json_path); if(gateway == NULL) { LogError("An error ocurred while creating the gateway."); result = 1; } else { result = 0; printf("Gateway is running.\r\n"); // run the glib loop g_main_loop_run(loop); printf("Gateway is quitting\r\n"); Gateway_Destroy(gateway); } platform_deinit(); } else { LogError("Failed to initialize the platform"); result = 1; } } return result; }
int main(int argc, char** argv) { (void)argc, (void)argv; if (platform_init() != 0) { LogError("Cannot initialize platform.\n"); } else { show_platform_info(); show_sastoken_example(); #ifdef USE_HTTP http_examples(); test_http_proxy_io(); #endif platform_deinit(); } return 0; }
static void __exit ccci_exit(void) { unsigned int md_num = 1, i; //1. Get Support MD nmmber md_num = get_md_sys_max_num(); //2. Init ccci driver for each modem for(i=0; i<md_num; i++) { // 3.1 de-Init virtual char dev ccci_vir_chrdev_exit(i); // 3.2 de-Init ccmni dev ccmni_exit(i); // 3.3 de-Init fs dev ccci_fs_exit(i); // 3.4 de-Init rpc dev ccci_rpc_exit(i); // 3.5 de-Init ipc dev ccci_ipc_exit(i); // 3.6 de-Init tty dev ccci_tty_exit(i); // 3.7 de-Init char dev ccci_chrdev_exit(i); // 3.8 De-Init md ctrl ccci_md_ctrl_exit(i); // 3.9 de-Init ccci logical layer ccci_logic_layer_exit(i); // 3.10 de-Init ccci platform layer platform_deinit(i); // 3.11 de-Init ccci device node ccci_dev_node_exit(i); } // 3.12 release ccci class release_ccci_dev_node(); // 3.13 de-Init ccci helper grobal data ccci_helper_exit(); }
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(); } }
int main() { int result; if (platform_init() == 0 && initialize_hsm_system() == 0) { HSM_CLIENT_HANDLE hsm_handle; if ((hsm_handle = hsm_client_riot_create()) == NULL) { (void)printf("Failure getting common name\r\n"); result = __LINE__; } else { char* enroll_type = get_user_input("Would you like to do Individual (i) or Group (g) enrollments: ", 1); if (enroll_type != NULL) { if (enroll_type[0] == 'g' || enroll_type[0] == 'G') { if (ca_root_certificate_info(hsm_handle) != 0) { result = __LINE__; } else { result = 0; } } else { if (alias_certificate_info(hsm_handle) != 0) { result = __LINE__; } else { result = 0; } } free(enroll_type); } else { (void)printf("Invalid option specified\r\n"); result = __LINE__; } hsm_client_riot_destroy(hsm_handle); } deinitialize_hsm_system(); platform_deinit(); } else { (void)printf("Failed calling platform_init\r\n"); result = __LINE__; } (void)printf("Press any key to continue:\r\n"); (void)getchar(); return result; }
void iothub_client_sample_mqtt_run(void) { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle; EVENT_INSTANCE messages[MESSAGE_COUNT]; g_continueRunning = true; srand((unsigned int)time(NULL)); double avgWindSpeed = 10.0; callbackCounter = 0; int receiveContext = 0; if (platform_init() != 0) { (void)printf("Failed to initialize the platform.\r\n"); } else { if ((iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, MQTT_Protocol)) == NULL) { (void)printf("ERROR: iotHubClientHandle is NULL!\r\n"); } else { bool traceOn = true; IoTHubClient_LL_SetOption(iotHubClientHandle, "logtrace", &traceOn); #ifdef MBED_BUILD_TIMESTAMP // For mbed add the certificate information if (IoTHubClient_LL_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_LL_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, &receiveContext) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SetMessageCallback..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_LL_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) { sprintf_s(msgText, sizeof(msgText), "{\"deviceId\":\"myFirstDevice\",\"windSpeed\":%.2f}", avgWindSpeed + (rand() % 4 + 2)); if ((messages[iterator].messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText))) == NULL) { (void)printf("ERROR: iotHubMessageHandle is NULL!\r\n"); } else { messages[iterator].messageTrackingId = iterator; MAP_HANDLE propMap = IoTHubMessage_Properties(messages[iterator].messageHandle); sprintf_s(propText, sizeof(propText), "PropMsg_%d", iterator); if (Map_AddOrUpdate(propMap, "PropName", propText) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate Failed!\r\n"); } if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messages[iterator].messageHandle, SendConfirmationCallback, &messages[iterator]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SendEventAsync..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_LL_SendEventAsync accepted message [%d] for transmission to IoT Hub.\r\n", (int)iterator); } } } IoTHubClient_LL_DoWork(iotHubClientHandle); 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(iotHubClientHandle); ThreadAPI_Sleep(1); } } IoTHubClient_LL_Destroy(iotHubClientHandle); } 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(); } }
void simplesample_mqtt_run(void) { if (platform_init() != 0) { (void)printf("Failed to initialize 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, MQTT_Protocol); srand((unsigned int)time(NULL)); int avgWindSpeed = 10; if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_LL_Create\r\n"); } else { #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 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(); } platform_deinit(); } }
static void remote_monitoring_run(void) { if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { if (serializer_init(NULL) != SERIALIZER_OK) { printf("Failed on serializer_init\r\n"); } else { IOTHUB_CLIENT_CONFIG config; IOTHUB_CLIENT_HANDLE iotHubClientHandle; config.deviceSasToken = NULL; config.deviceId = deviceId; config.deviceKey = deviceKey; config.iotHubName = hubName; config.iotHubSuffix = hubSuffix; #ifndef WINCE config.protocol = AMQP_Protocol; #else config.protocol = HTTP_Protocol; #endif iotHubClientHandle = IoTHubClient_Create(&config); if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_CreateFromConnectionString\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 Thermostat* thermostat = CREATE_MODEL_INSTANCE(Contoso, Thermostat); if (thermostat == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { STRING_HANDLE commandsMetadata; if (IoTHubClient_SetMessageCallback(iotHubClientHandle, IoTHubMessage, thermostat) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { /* send the device info upon startup so that the cloud app knows what commands are available and the fact that the device is up */ thermostat->ObjectType = "DeviceInfo"; thermostat->IsSimulatedDevice = false; thermostat->Version = "1.0"; thermostat->DeviceProperties.HubEnabledState = true; thermostat->DeviceProperties.DeviceID = (char*)deviceId; commandsMetadata = STRING_new(); if (commandsMetadata == NULL) { (void)printf("Failed on creating string for commands metadata\r\n"); } else { /* Serialize the commands metadata as a JSON string before sending */ if (SchemaSerializer_SerializeCommandMetadata(GET_MODEL_HANDLE(Contoso, Thermostat), commandsMetadata) != SCHEMA_SERIALIZER_OK) { (void)printf("Failed serializing commands metadata\r\n"); } else { unsigned char* buffer; size_t bufferSize; thermostat->Commands = (char*)STRING_c_str(commandsMetadata); /* Here is the actual send of the Device Info */ if (SERIALIZE(&buffer, &bufferSize, thermostat->ObjectType, thermostat->Version, thermostat->IsSimulatedDevice, thermostat->DeviceProperties, thermostat->Commands) != IOT_AGENT_OK) { (void)printf("Failed serializing\r\n"); } else { sendMessage(iotHubClientHandle, buffer, bufferSize); } } STRING_delete(commandsMetadata); } thermostat->Temperature = 50; thermostat->ExternalTemperature = 55; thermostat->Humidity = 50; thermostat->DeviceId = (char*)deviceId; while (1) { unsigned char*buffer; size_t bufferSize; float tempC = -300.0; float pressurePa = -300; float humidityPct = -300; int sensorResult = bme280_read_sensors(&tempC, &pressurePa, &humidityPct); if (sensorResult == 1) { thermostat->Temperature = tempC; thermostat->Humidity = humidityPct; printf("Humidity = %.1f%% Temperature = %.1f*C \n", humidityPct, tempC); pinMode(Grn_led_pin, OUTPUT); } else { thermostat->Temperature = 404.0; thermostat->Humidity = 404.0; printf("Unable to read BME280 on pin %i\n", Spi_channel); pinMode(Red_led_pin, OUTPUT); } (void)printf("Sending sensor value Temperature = %.1f*C, Humidity = %.1f%%\r\n", thermostat->Temperature, thermostat->Humidity); if (SERIALIZE(&buffer, &bufferSize, thermostat->DeviceId, thermostat->Temperature, thermostat->Humidity, thermostat->ExternalTemperature) != IOT_AGENT_OK) { (void)printf("Failed sending sensor value\r\n"); } else { sendMessage(iotHubClientHandle, buffer, bufferSize); } ThreadAPI_Sleep(1000); } } close_lockfile(Lock_fd); DESTROY_MODEL_INSTANCE(thermostat); } IoTHubClient_Destroy(iotHubClientHandle); } serializer_deinit(); } platform_deinit(); } }
static int __init ccci_init(void) { int ret = CCCI_ERR_MODULE_INIT_OK; unsigned int md_num = 1; int i = 0; int md_en[MAX_MD_NUM] = {0}; //1. Get and set Support MD nmmber md_num = get_md_sys_max_num(); set_md_sys_max_num(md_num); //2. Get and set MD enable table for(i = 0; i < md_num; i++) { if(get_modem_is_enabled(i)){ md_en[i] = 1; set_md_enable(i, 1); } else { md_en[i] = 0; set_md_enable(i, 0); } } #ifdef ENABLE_CCCI_DRV_BUILDIN CCCI_MSG("ccci_init: device_initcall_sync\n"); #else // MODULE CCCI_MSG("ccci_init: module_init\n"); #endif //3. Init ccci device table ret = init_ccci_dev_node(); if(ret) { CCCI_MSG("init_ccci_dev_node fail: %d\n", ret); ret = -CCCI_ERR_INIT_DEV_NODE_FAIL; goto out; } //4. Init ccci driver for each modem for(i = 0; i < md_num; i++) { if(md_en[i] == 0) { CCCI_MSG_INF(i, "cci", "md initial fail: md%d is not enabled\n", i+1); continue; } // 4.0 Init platform support function ret = platform_init(i, !md_en[i]); if (ret) { CCCI_MSG_INF(i, "cci", "platform_init fail: %d\n", ret); ret = -CCCI_ERR_INIT_PLATFORM_FAIL; goto platform_out; } else { CCCI_DBG_MSG(i, "cci", "platform_init OK!\n"); } // Make ccci device node ret = mk_ccci_dev_node(i); if (ret) { CCCI_MSG_INF(i, "cci", "mk_ccci_dev_node fail: %d\n", ret); ret = -CCCI_ERR_MK_DEV_NODE_FAIL; goto mk_node_out; } else { CCCI_DBG_MSG(i, "cci", "mk_ccci_dev_node OK!\n"); } // Statistics init statistics_init(i); // 4.1 Init ccci logical layer ret = ccci_logic_layer_init(i); if(ret) { CCCI_MSG_INF(i, "cci", "ccci logical layer init fail: %d\n", ret); ret = -CCCI_ERR_INIT_LOGIC_LAYER_FAIL; goto logic_out; } else { CCCI_DBG_MSG(i, "cci", "ccci_logic_layer_init OK!\n"); } // 4.2 Init md ctrl ret = ccci_md_ctrl_init(i); if(ret) { CCCI_MSG_INF(i, "cci", "ccci md ctrl init fail: %d\n", ret); ret = -CCCI_ERR_INIT_MD_CTRL_FAIL; goto mdctl_out; } else { CCCI_DBG_MSG(i, "cci", "ccci_md_ctrl_init OK!\n"); } // 4.3 Init char dev ret = ccci_chrdev_init(i); if (ret) { CCCI_MSG_INF(i, "cci", "ccci_chrdev_init fail: %d\n", ret); ret = -CCCI_ERR_INIT_CHAR_DEV_FAIL; goto char_out; } else { CCCI_DBG_MSG(i, "cci", "ccci_chrdev_init OK!\n"); } // 4.4 Init tty dev ret = ccci_tty_init(i); if (ret) { CCCI_MSG_INF(i, "cci", "ccci_tty_init fail: %d\n", ret); ret = -CCCI_ERR_INIT_TTY_FAIL; goto tty_out; } else { CCCI_DBG_MSG(i, "cci", "ccci_tty_init OK!\n"); } // 4.5 Init ipc dev ret = ccci_ipc_init(i); if (ret) { CCCI_MSG_INF(i, "cci", "ccci_ipc_init fail: %d\n", ret); ret = -CCCI_ERR_INIT_IPC_FAIL; goto ipc_out; } else { CCCI_DBG_MSG(i, "cci", "ccci_ipc_init OK!\n"); } // 4.6 Init rpc dev ret = ccci_rpc_init(i); if (ret) { CCCI_MSG_INF(i, "cci", "ccci_rpc_init fail: %d\n", ret); ret = -CCCI_ERR_INIT_RPC_FAIL; goto rpc_out; } else { CCCI_DBG_MSG(i, "cci", "ccci_rpc_init OK!\n"); } // 4.7 Init fs dev ret = ccci_fs_init(i); if (ret) { CCCI_MSG_INF(i, "cci", "ccci_fs_init fail: %d\n", ret); ret = -CCCI_ERR_INIT_FS_FAIL; goto fs_out; } else { CCCI_DBG_MSG(i, "cci", "ccci_fs_init OK!\n"); } // 4.8 Init ccmni dev ret = ccmni_init(i); if (ret) { CCCI_MSG_INF(i, "cci", "ccmni_init fail: %d\n", ret); ret = -CCCI_ERR_INIT_CCMNI_FAIL; goto ccmni_out; } else { CCCI_DBG_MSG(i, "cci", "ccmni_init OK!\n"); } // 4.9 Init pmic dev // .... // 4.10 Init vir char dev ret = ccci_vir_chrdev_init(i); if (ret) { CCCI_MSG_INF(i, "cci", "ccci_vir_chrdev_init fail: %d\n", ret); ret = -CCCI_ERR_INIT_VIR_CHAR_FAIL; goto virchar_out; } else { CCCI_DBG_MSG(i, "cci", "ccci_vir_chrdev_init OK!\n"); } CCCI_MSG_INF(i, "cci", "md initial OK!\n"); } // 5. Init common section ret = ccci_md_ctrl_common_init(); if (ret == 0) goto out; else { i = md_num-1; CCCI_MSG_INF(i, "cci", "ccci_md_ctrl_common_init fail: %d\n", ret); } virchar_out: ccci_vir_chrdev_exit(i); ccmni_out: ccmni_exit(i); fs_out: ccci_fs_exit(i); rpc_out: ccci_rpc_exit(i); ipc_out: ccci_ipc_exit(i); tty_out: ccci_tty_exit(i); char_out: ccci_chrdev_exit(i); mdctl_out: ccci_md_ctrl_exit(i); logic_out: ccci_logic_layer_exit(i); platform_out: platform_deinit(i); mk_node_out: ccci_dev_node_exit(i); out: if ((i == MD_SYS2) && (md_num > MD_SYS2)) { ccci_vir_chrdev_exit(MD_SYS1); ccmni_exit(MD_SYS1); ccci_fs_exit(MD_SYS1); ccci_rpc_exit(MD_SYS1); ccci_ipc_exit(MD_SYS1); ccci_tty_exit(MD_SYS1); ccci_chrdev_exit(MD_SYS1); ccci_md_ctrl_exit(MD_SYS1); ccci_logic_layer_exit(MD_SYS1); platform_deinit(MD_SYS1); ccci_dev_node_exit(MD_SYS1); } if (ret == CCCI_ERR_MODULE_INIT_OK) CCCI_MSG("ccci module init OK\n"); else { release_ccci_dev_node(); ccci_helper_exit(); CCCI_MSG("ccci module init fail: %d\n", ret); } return ret; }
static int iothub_client_sample_mqtt_dm_run(const char *connectionString, bool traceOn) { LogInfo("Initialize Platform"); int retValue; if (platform_init() != 0) { LogError("Failed to initialize the platform."); retValue = -4; } else { if (serializer_init(NULL) != SERIALIZER_OK) { LogError("Failed in serializer_init."); retValue = -5; } else { LogInfo("Instantiate the device."); thingie_t *iot_device = CREATE_MODEL_INSTANCE(Contoso, thingie_t); if (iot_device == NULL) { LogError("Failed on CREATE_MODEL_INSTANCE."); retValue = -6; } else { LogInfo("Initialize From Connection String."); IOTHUB_CLIENT_HANDLE iotHubClientHandle = IoTHubClient_CreateFromConnectionString(connectionString, MQTT_Protocol); if (iotHubClientHandle == NULL) { LogError("iotHubClientHandle is NULL!"); retValue = -7; } else { LogInfo("Device successfully connected."); if (IoTHubClient_SetOption(iotHubClientHandle, "logtrace", &traceOn) != IOTHUB_CLIENT_OK) { LogError("failed to set logtrace option"); } PHYSICAL_DEVICE *physical_device = physical_device_new(iot_device); if (physical_device == NULL) { LogError("failed to make an iot device callback structure"); retValue = -8; } else { if (IoTHubClient_SetDeviceMethodCallback(iotHubClientHandle, DeviceMethodCallback, physical_device) != IOTHUB_CLIENT_OK) { LogError("failed to associate a callback for device methods"); retValue = -9; } else { bool keepRunning = send_reported(physical_device, iotHubClientHandle); if (!keepRunning) { LogError("Failed to send initia device reported"); retValue = -10; } else { FIRMWARE_UPDATE_STATUS oldStatus = get_physical_device_fwupdate_status(physical_device); while (keepRunning) { FIRMWARE_UPDATE_STATUS newStatus = get_physical_device_fwupdate_status(physical_device); /* send reported only if the status changes */ if (newStatus != oldStatus) { oldStatus = newStatus; keepRunning = send_reported(physical_device, iotHubClientHandle); } ThreadAPI_Sleep(1000); } retValue = 0; } } physical_device_delete(physical_device); } IoTHubClient_Destroy(iotHubClientHandle); } DESTROY_MODEL_INSTANCE(iot_device); } serializer_deinit(); } platform_deinit(); } return retValue; }
int main(int argc, char** argv) { int result; (void)argc, argv; amqpalloc_set_memory_tracing_enabled(true); if (platform_init() != 0) { result = -1; } else { CONNECTION_HANDLE connection; SESSION_HANDLE session; LINK_HANDLE link; MESSAGE_SENDER_HANDLE message_sender; MESSAGE_HANDLE message; size_t last_memory_used = 0; /* create socket IO */ XIO_HANDLE socket_io; SOCKETIO_CONFIG socketio_config = { "localhost", 5672, NULL }; socket_io = xio_create(socketio_get_interface_description(), &socketio_config); /* create the connection, session and link */ connection = connection_create(socket_io, "localhost", "some", NULL, NULL); session = session_create(connection, NULL, NULL); session_set_incoming_window(session, 2147483647); session_set_outgoing_window(session, 65536); AMQP_VALUE source = messaging_create_source("ingress"); AMQP_VALUE target = messaging_create_target("localhost/ingress"); link = link_create(session, "sender-link", role_sender, source, target); link_set_snd_settle_mode(link, sender_settle_mode_settled); (void)link_set_max_message_size(link, 65536); amqpvalue_destroy(source); amqpvalue_destroy(target); message = message_create(); unsigned char hello[] = { 'H', 'e', 'l', 'l', 'o' }; BINARY_DATA binary_data; binary_data.bytes = hello; binary_data.length = sizeof(hello); message_add_body_amqp_data(message, binary_data); /* create a message sender */ message_sender = messagesender_create(link, NULL, NULL); if (messagesender_open(message_sender) == 0) { uint32_t i; #if _WIN32 unsigned long startTime = (unsigned long)GetTickCount64(); #endif for (i = 0; i < msg_count; i++) { (void)messagesender_send(message_sender, message, on_message_send_complete, message); } message_destroy(message); while (true) { size_t current_memory_used; size_t maximum_memory_used; connection_dowork(connection); current_memory_used = amqpalloc_get_current_memory_used(); maximum_memory_used = amqpalloc_get_maximum_memory_used(); if (current_memory_used != last_memory_used) { (void)printf("Current memory usage:%lu (max:%lu)\r\n", (unsigned long)current_memory_used, (unsigned long)maximum_memory_used); last_memory_used = current_memory_used; } if (sent_messages == msg_count) { break; } } #if _WIN32 unsigned long endTime = (unsigned long)GetTickCount64(); (void)printf("Send %zu messages in %lu ms: %.02f msgs/sec\r\n", msg_count, (endTime - startTime), (float)msg_count / ((float)(endTime - startTime) / 1000)); #endif } messagesender_destroy(message_sender); link_destroy(link); session_destroy(session); connection_destroy(connection); xio_destroy(socket_io); platform_deinit(); (void)printf("Max memory usage:%lu\r\n", (unsigned long)amqpalloc_get_maximum_memory_used()); (void)printf("Current memory usage:%lu\r\n", (unsigned long)amqpalloc_get_current_memory_used()); result = 0; } #ifdef _CRTDBG_MAP_ALLOC _CrtDumpMemoryLeaks(); #endif return result; }
void simplesample_amqp_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 { /* Setup IoTHub client configuration */ IOTHUB_CLIENT_HANDLE iotHubClientHandle = IoTHubClient_CreateFromConnectionString(connectionString, AMQP_Protocol); srand((unsigned int)time(NULL)); int avgWindSpeed = 10; // Turn on Log bool trace = true; (void)IoTHubClient_SetOption(iotHubClientHandle, "logtrace", &trace); if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_Create\r\n"); } else { #ifdef MBED_BUILD_TIMESTAMP // For mbed add the certificate information if (IoTHubClient_SetOption(iotHubClientHandle, "TrustedCerts", certificates) != IOTHUB_CLIENT_OK) { (void)printf("failure to set option \"TrustedCerts\"\r\n"); } #endif // MBED_BUILD_TIMESTAMP ContosoAnemometer* myWeather = CREATE_MODEL_INSTANCE(WeatherStation, ContosoAnemometer); if (myWeather == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { unsigned char* destination; size_t destinationSize; if (IoTHubClient_SetMessageCallback(iotHubClientHandle, IoTHubMessage, myWeather) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { myWeather->DeviceId = "myFirstDevice"; myWeather->WindSpeed = avgWindSpeed + (rand() % 4 + 2); if (SERIALIZE(&destination, &destinationSize, myWeather->DeviceId, myWeather->WindSpeed) != CODEFIRST_OK) { (void)printf("Failed to serialize\r\n"); } else { sendMessage(iotHubClientHandle, destination, destinationSize); } /* wait for commands */ (void)getchar(); } DESTROY_MODEL_INSTANCE(myWeather); } IoTHubClient_Destroy(iotHubClientHandle); } serializer_deinit(); } platform_deinit(); } }
void devicemethod_simplesample_run(void) { if (platform_init() != 0) { (void)printf("Failed to initialize 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, MQTT_Protocol); srand((unsigned int)time(NULL)); int avgWindSpeed = 10; if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_LL_Create\r\n"); } else { #ifdef SET_TRUSTED_CERT_IN_SAMPLES // 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 // SET_TRUSTED_CERT_IN_SAMPLES ContosoAnemometer* myWeather = CREATE_MODEL_INSTANCE(WeatherStation, ContosoAnemometer); if (myWeather == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else if (IoTHubClient_LL_SetDeviceMethodCallback(iotHubClientHandle, DeviceMethodCallback, myWeather) != IOTHUB_CLIENT_OK) { (void)printf("Failed on IoTHubClient_SetDeviceMethodCallback\r\n"); } else { if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, myWeather) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { myWeather->DeviceId = "myWeatherStation"; 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 { sendMessage(iotHubClientHandle, destination, destinationSize); 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(); } }
int main(int argc, char** argv) { int result; XIO_HANDLE sasl_io = NULL; CONNECTION_HANDLE connection = NULL; SESSION_HANDLE session = NULL; LINK_HANDLE link = NULL; MESSAGE_RECEIVER_HANDLE message_receiver = NULL; amqpalloc_set_memory_tracing_enabled(true); if (platform_init() != 0) { result = -1; } else { size_t last_memory_used = 0; /* create SASL plain handler */ SASL_PLAIN_CONFIG sasl_plain_config = { EH_KEY_NAME, EH_KEY, NULL }; SASL_MECHANISM_HANDLE sasl_mechanism_handle = saslmechanism_create(saslplain_get_interface(), &sasl_plain_config); XIO_HANDLE tls_io; /* create the TLS IO */ TLSIO_CONFIG tls_io_config = { EH_HOST, 5671 }; const IO_INTERFACE_DESCRIPTION* tlsio_interface = platform_get_default_tlsio(); tls_io = xio_create(tlsio_interface, &tls_io_config, NULL); /* create the SASL client IO using the TLS IO */ SASLCLIENTIO_CONFIG sasl_io_config = { tls_io, sasl_mechanism_handle }; sasl_io = xio_create(saslclientio_get_interface_description(), &sasl_io_config, NULL); /* create the connection, session and link */ connection = connection_create(sasl_io, EH_HOST, "whatever", NULL, NULL); session = session_create(connection, NULL, NULL); /* set incoming window to 100 for the session */ session_set_incoming_window(session, 100); AMQP_VALUE source = messaging_create_source("amqps://" EH_HOST "/ingress/ConsumerGroups/$Default/Partitions/0"); AMQP_VALUE target = messaging_create_target("ingress-rx"); link = link_create(session, "receiver-link", role_receiver, source, target); link_set_rcv_settle_mode(link, receiver_settle_mode_first); amqpvalue_destroy(source); amqpvalue_destroy(target); /* create a message receiver */ message_receiver = messagereceiver_create(link, NULL, NULL); if ((message_receiver == NULL) || (messagereceiver_open(message_receiver, on_message_received, message_receiver) != 0)) { result = -1; } else { while (true) { size_t current_memory_used; size_t maximum_memory_used; connection_dowork(connection); current_memory_used = amqpalloc_get_current_memory_used(); maximum_memory_used = amqpalloc_get_maximum_memory_used(); if (current_memory_used != last_memory_used) { printf("Current memory usage:%lu (max:%lu)\r\n", (unsigned long)current_memory_used, (unsigned long)maximum_memory_used); last_memory_used = current_memory_used; } } result = 0; } messagereceiver_destroy(message_receiver); link_destroy(link); session_destroy(session); connection_destroy(connection); platform_deinit(); printf("Max memory usage:%lu\r\n", (unsigned long)amqpalloc_get_maximum_memory_used()); printf("Current memory usage:%lu\r\n", (unsigned long)amqpalloc_get_current_memory_used()); #ifdef _CRTDBG_MAP_ALLOC _CrtDumpMemoryLeaks(); #endif } return result; }
void iothub_client_sample_http_run(void) { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle; EVENT_INSTANCE messages[MESSAGE_COUNT]; double avgWindSpeed = 10.0; int receiveContext = 0; g_continueRunning = true; 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 x509...\r\n"); if ((iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, HTTP_Protocol)) == NULL) { (void)printf("ERROR: iotHubClientHandle 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; if (IoTHubClient_LL_SetOption(iotHubClientHandle, "timeout", &timeout) != IOTHUB_CLIENT_OK) { printf("failure to set option \"timeout\"\r\n"); } if (IoTHubClient_LL_SetOption(iotHubClientHandle, "MinimumPollingTime", &minimumPollingTime) != IOTHUB_CLIENT_OK) { printf("failure to set option \"MinimumPollingTime\"\r\n"); } /*this brings in x509 privateKey and certificate*/ if ( (IoTHubClient_LL_SetOption(iotHubClientHandle, "x509certificate", x509certificate) != IOTHUB_CLIENT_OK) || (IoTHubClient_LL_SetOption(iotHubClientHandle, "x509privatekey", x509privatekey) != IOTHUB_CLIENT_OK) ) { printf("failure to set options for x509, aborting\r\n"); } else { #ifdef MBED_BUILD_TIMESTAMP // For mbed add the certificate information if (IoTHubClient_LL_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_LL_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, &receiveContext) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SetMessageCallback..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_LL_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) { sprintf_s(msgText, sizeof(msgText), "{\"deviceId\": \"myFirstDevice\",\"windSpeed\": %.2f}", avgWindSpeed + (rand() % 4 + 2)); if ((messages[iterator].messageHandle = IoTHubMessage_CreateFromByteArray((const unsigned char*)msgText, strlen(msgText))) == NULL) { (void)printf("ERROR: iotHubMessageHandle is NULL!\r\n"); } else { MAP_HANDLE propMap; messages[iterator].messageTrackingId = iterator; propMap = IoTHubMessage_Properties(messages[iterator].messageHandle); sprintf_s(propText, sizeof(propText), "PropMsg_%d", iterator); if (Map_AddOrUpdate(propMap, "PropName", propText) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate Failed!\r\n"); } if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messages[iterator].messageHandle, SendConfirmationCallback, &messages[iterator]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SendEventAsync..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_LL_SendEventAsync accepted message [%zu] for transmission to IoT Hub.\r\n", iterator); } } } IoTHubClient_LL_DoWork(iotHubClientHandle); 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(iotHubClientHandle); ThreadAPI_Sleep(1); } } } IoTHubClient_LL_Destroy(iotHubClientHandle); } platform_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 iothub_client_sample_mqtt_run(void) { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle; EVENT_INSTANCE messages[MESSAGE_COUNT]; continueRunning = true; srand((unsigned int)time(NULL)); double avgWindSpeed = 10.0; callbackCounter = 0; int receiveContext = 0; (void)printf("Starting the IoTHub client sample MQTT...\r\n"); if (platform_init() != 0) { (void)printf("ERROR: platform_init fails!\r\n"); } else { if ((iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, MQTT_Protocol)) == NULL) { (void)printf("ERROR: iotHubClientHandle is NULL!\r\n"); } else { bool traceOn = true; IoTHubClient_LL_SetOption(iotHubClientHandle, "logtrace", &traceOn); /* Setting Message call back, so we can receive Commands. */ if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, ReceiveMessageCallback, &receiveContext) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SetMessageCallback..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_LL_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; if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messages[i].messageHandle, SendConfirmationCallback, &messages[i]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SendEventAsync..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_LL_SendEventAsync accepted message [%d] for transmission to IoT Hub.\r\n", (int)i); } } } } /* Wait for Commands. */ while (continueRunning) { IoTHubClient_LL_DoWork(iotHubClientHandle); ThreadAPI_Sleep(1); } IoTHubClient_LL_Destroy(iotHubClientHandle); } platform_deinit(); } }
int main(int argc, char *argv[]) { if(argc <= 1) return print_usage(argv[0]); main_argc = argc; main_argv = argv; if(!strcmp(argv[1], "-c")) { if(argc <= 3) return print_usage(argv[0]); char *net_addr = argv[2]; int net_port = atoi(argv[3]); printf("TODO: connect to \"%s\" port %i\n", net_addr, net_port); main_largstart = 4; boot_mode = 1; return 101; } else if(!strcmp(argv[1], "-s")) { if(argc <= 3) return print_usage(argv[0]); int net_port = atoi(argv[2]); mod_basedir = argv[3]; printf("TODO: run a server on port %i, mod \"%s\"\n", net_port, mod_basedir); main_largstart = 4; boot_mode = 3; } else if(!strcmp(argv[1], "-d")) { if(argc <= 3) return print_usage(argv[0]); int net_port = atoi(argv[2]); mod_basedir = argv[3]; printf("TODO: run a ded server on port %i, mod \"%s\"\n", net_port, mod_basedir); main_largstart = 4; boot_mode = 2; return 101; } else { return print_usage(argv[0]); } if(memcmp(mod_basedir,"pkg/",4)) { fprintf(stderr, "ERROR: package base dir must start with \"pkg/\"!\n"); return 109; } if(strlen(mod_basedir) < 5) { fprintf(stderr, "ERROR: package base dir can't actually be \"pkg/\"!\n"); return 109; } if((!(boot_mode & 1)) || !platform_init()) { if(!icelua_init()) { if(!net_init()) { if((!(boot_mode & 1)) || !video_init()) { if((!(boot_mode & 1)) || !wav_init()) { if((!(boot_mode & 1)) || !render_init(screen->w, screen->h)) { run_game(); if(boot_mode & 1) render_deinit(); } if(boot_mode & 1) wav_deinit(); } if(boot_mode & 1) video_deinit(); } net_deinit(); } icelua_deinit(); } if(boot_mode & 1) platform_deinit(); } return 0; }
int main(int argc, char** argv) { int result; (void)argc, argv; amqpalloc_set_memory_tracing_enabled(true); if (platform_init() != 0) { result = -1; } else { XIO_HANDLE sasl_io; CONNECTION_HANDLE connection; SESSION_HANDLE session; LINK_HANDLE link; MESSAGE_SENDER_HANDLE message_sender; MESSAGE_HANDLE message; size_t last_memory_used = 0; /* create SASL PLAIN handler */ SASL_PLAIN_CONFIG sasl_plain_config = { EH_KEY_NAME, EH_KEY, NULL }; SASL_MECHANISM_HANDLE sasl_mechanism_handle = saslmechanism_create(saslplain_get_interface(), &sasl_plain_config); XIO_HANDLE tls_io; /* create the TLS IO */ TLSIO_CONFIG tls_io_config = { EH_HOST, 5671 }; const IO_INTERFACE_DESCRIPTION* tlsio_interface = platform_get_default_tlsio(); tls_io = xio_create(tlsio_interface, &tls_io_config); /* create the SASL client IO using the TLS IO */ SASLCLIENTIO_CONFIG sasl_io_config; sasl_io_config.underlying_io = tls_io; sasl_io_config.sasl_mechanism = sasl_mechanism_handle; sasl_io = xio_create(saslclientio_get_interface_description(), &sasl_io_config); /* create the connection, session and link */ connection = connection_create(sasl_io, EH_HOST, "some", NULL, NULL); session = session_create(connection, NULL, NULL); session_set_incoming_window(session, 2147483647); session_set_outgoing_window(session, 65536); AMQP_VALUE source = messaging_create_source("ingress"); AMQP_VALUE target = messaging_create_target("amqps://" EH_HOST "/" EH_NAME); link = link_create(session, "sender-link", role_sender, source, target); link_set_snd_settle_mode(link, sender_settle_mode_unsettled); (void)link_set_max_message_size(link, 65536); amqpvalue_destroy(source); amqpvalue_destroy(target); message = message_create(); unsigned char hello[] = { 'H', 'e', 'l', 'l', 'o' }; BINARY_DATA binary_data; binary_data.bytes = hello; binary_data.length = sizeof(hello); message_add_body_amqp_data(message, binary_data); /* create a message sender */ message_sender = messagesender_create(link, NULL, NULL); if (messagesender_open(message_sender) == 0) { uint32_t i; #if _WIN32 unsigned long startTime = (unsigned long)GetTickCount64(); #endif for (i = 0; i < msg_count; i++) { (void)messagesender_send(message_sender, message, on_message_send_complete, message); } message_destroy(message); while (true) { size_t current_memory_used; size_t maximum_memory_used; connection_dowork(connection); current_memory_used = amqpalloc_get_current_memory_used(); maximum_memory_used = amqpalloc_get_maximum_memory_used(); if (current_memory_used != last_memory_used) { (void)printf("Current memory usage:%lu (max:%lu)\r\n", (unsigned long)current_memory_used, (unsigned long)maximum_memory_used); last_memory_used = current_memory_used; } if (sent_messages == msg_count) { break; } } #if _WIN32 unsigned long endTime = (unsigned long)GetTickCount64(); (void)printf("Send %zu messages in %lu ms: %.02f msgs/sec\r\n", msg_count, (endTime - startTime), (float)msg_count / ((float)(endTime - startTime) / 1000)); #endif } messagesender_destroy(message_sender); link_destroy(link); session_destroy(session); connection_destroy(connection); xio_destroy(sasl_io); xio_destroy(tls_io); saslmechanism_destroy(sasl_mechanism_handle); platform_deinit(); (void)printf("Max memory usage:%lu\r\n", (unsigned long)amqpalloc_get_maximum_memory_used()); (void)printf("Current memory usage:%lu\r\n", (unsigned long)amqpalloc_get_current_memory_used()); result = 0; } #ifdef _CRTDBG_MAP_ALLOC _CrtDumpMemoryLeaks(); #endif return result; }
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(); } }