int rem_ctrl_http_init(void) { digitalWrite(redLedPin, LOW); pinMode(redLedPin, OUTPUT); digitalWrite(greenLedPin, LOW); pinMode(greenLedPin, OUTPUT); if (serializer_init(NULL) != SERIALIZER_OK) { (void)printf("Failed on serializer_init\r\n"); } else { Init_level__i = 1; iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, HTTP_Protocol); if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_LL_Create\r\n"); } else { Init_level__i = 2; 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) { printf("failure to set option \"MinimumPollingTime\"\r\n"); } myWeather = CREATE_MODEL_INSTANCE(RemoteMonitorExample, BME280_data); if (myWeather == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { Init_level__i = 3; if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, myWeather) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { Init_level__i = 4; } } } } return Init_level__i; }
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(); } }
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(); } }
int main(void) { pc.baud(115200); THREAD_HANDLE ThreadHandle; (void)printf("Initializing mbed specific things...\r\n"); (void)printf("doing a one time EthernetInterface::init();\r\n"); if (EthernetInterface::init() != 0) { (void)printf("Failed EthernetInterface::init();\r\n"); return -1; } (void)printf("done doing a one time EthernetInterface::init();\r\n"); if (setupRealTime() != 0) { (void)printf("Failed setting up real time clock\r\n"); return -1; } /* clear the LED light upon startup */ red_led = 1; blue_led = 1; green_led = 1; alarm_type = ALARM_NONE; led_on = 0; /* clear the screen */ lcd.cls(); if (ThreadAPI_Create(&ThreadHandle, LED_Update_Thread, NULL) != THREADAPI_OK) { (void)printf("Error spinning LED update thread.\r\n"); return -1; } /* initialize the IoTHubClient */ if (serializer_init(NULL) != SERIALIZER_OK) { (void)printf("Failed on serializer_init\r\n"); } else { /* Setup IoTHub client configuration */ IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, HTTP_Protocol); if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_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) { printf("failure to set option \"MinimumPollingTime\"\r\n"); } FrdmDevice* frdmDevice = CREATE_MODEL_INSTANCE(Contoso, FrdmDevice, true); if (frdmDevice == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { IOTHUB_CLIENT_RESULT setMessageResult = IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, frdmDevice); if (setMessageResult != IOTHUB_CLIENT_OK) { (void)printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { STRING_HANDLE commandsMetadata; temp = (sensor.temp() * 9 / 5) + 32; /* send the device info upon startup so that the cloud app knows what commands are available and the fact that the device is up */ frdmDevice->ObjectType = "DeviceInfo-HW"; frdmDevice->ObjectName = "An ALARM device"; frdmDevice->Version = "1.0"; frdmDevice->SystemProperties.DeviceID = (char*)deviceId; frdmDevice->SystemProperties.Enabled = true; /* build the description of the commands on the device */ 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, FrdmDevice), commandsMetadata) != SCHEMA_SERIALIZER_OK) { (void)printf("Failed serializing commands metadata\r\n"); } else { frdmDevice->Commands = (char*)STRING_c_str(commandsMetadata); /* Send the device information and commands metadata to the cloud */ { unsigned char* destination; size_t destinationSize; if (SERIALIZE(&destination, &destinationSize, frdmDevice->ObjectName, frdmDevice->ObjectType, frdmDevice->SystemProperties, frdmDevice->Version, frdmDevice->Commands) != IOT_AGENT_OK) { (void)printf("Failed to serialize\r\n"); } else { sendMessage(iotHubClientHandle, destination, destinationSize); free(destination); } } } STRING_delete(commandsMetadata); } frdmDevice->ObjectName = (ascii_char_ptr)deviceId; frdmDevice->ObjectType = "SensorTagEvent"; frdmDevice->Version = "1.0"; frdmDevice->TargetAlarmDevice = (ascii_char_ptr)deviceId; while (1) { unsigned char* destination; size_t destinationSize; (void)printf("Sending %.02f\r\n", temp); frdmDevice->temp = temp; if (SERIALIZE(&destination, &destinationSize, frdmDevice->ObjectName, frdmDevice->ObjectType, frdmDevice->Version, frdmDevice->TargetAlarmDevice, frdmDevice->temp) != IOT_AGENT_OK) { (void)printf("Failed to serialize\r\n"); } else { sendMessage(iotHubClientHandle, destination, destinationSize); free(destination); } /* schedule IoTHubClient to send events/receive commands */ IoTHubClient_LL_DoWork(iotHubClientHandle); } } DESTROY_MODEL_INSTANCE(frdmDevice); } IoTHubClient_LL_Destroy(iotHubClientHandle); } serializer_deinit(); } }
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 remote_monitoring_run(void) { if (serializer_init(NULL) != SERIALIZER_OK) { printf("Failed on serializer_init\r\n"); } else { IOTHUB_CLIENT_CONFIG config; config.deviceId = deviceId; config.deviceKey = deviceKey; config.iotHubName = hubName; config.iotHubSuffix = hubSuffix; config.protocol = AMQP_Protocol; IOTHUB_CLIENT_HANDLE iotHubClientHandle = IoTHubClient_Create(&config); if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_CreateFromConnectionString\r\n"); } else { unsigned int minimumPollingTime = 9; /*because it can poll "after 9 seconds" polls will happen effectively at ~10 seconds*/ if (IoTHubClient_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_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.0; thermostat->Humidity = 50.0; thermostat->DeviceId = (char*)deviceId; while (1) { unsigned char*buffer; size_t bufferSize; (void)printf("Sending sensor value Temperature = %02f, Humidity = %02f\r\n", thermostat->Temperature, thermostat->Humidity); if (SERIALIZE(&buffer, &bufferSize, thermostat->Temperature, thermostat->Humidity, thermostat->DeviceId) != IOT_AGENT_OK) { (void)printf("Failed sending sensor value\r\n"); } else { sendMessage(iotHubClientHandle, buffer, bufferSize); } ThreadAPI_Sleep(1000); } } DESTROY_MODEL_INSTANCE(thermostat); } IoTHubClient_Destroy(iotHubClientHandle); } serializer_deinit(); } }
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(); } }
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(); } }
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(); } }
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; }
void simplesample_amqp_run(void) { if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); exit(1); } 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 avgMTemperature = 10; 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 { int Lock_fd__i = open_lockfile(LOCKFILE); if (setuid(getuid()) < 0) { perror("Dropping privileges failed. (did you use sudo?)\n"); exit(EXIT_FAILURE); } int Result__i = wiringPiSetup(); if (Result__i != 0) exit(Result__i); int Spi_fd__i = wiringPiSPISetup(Spi_channel__i, Spi_clock__i); if (Spi_fd__i < 0) { printf("Can't setup SPI, error %i calling wiringPiSPISetup(%i, %i) %s\n", Spi_fd__i, Spi_channel__i, Spi_clock__i, strerror(Spi_fd__i)); exit(Spi_fd__i); } int Init_result__i = bme280_init(Spi_channel__i); if (Init_result__i != 1) { printf("It appears that no BMP280 module on Chip Enable %i is attached. Aborting.\n", Spi_channel__i); exit(1); } pinMode(Red_led_pin__i, OUTPUT); pinMode(Grn_led_pin__i, OUTPUT); //////////////// // Read the Temp & Pressure module. float Temp_C__f = -300.0; float Pressure_Pa__f = -300; float Humidity_pct__f = -300; Result__i = bme280_read_sensors(&Temp_C__f, &Pressure_Pa__f, &Humidity_pct__f); if (Result__i == 1) { printf("Temperature = %.1f *C Pressure = %.1f Pa Humidity = %1f %%\n", Temp_C__f, Pressure_Pa__f, Humidity_pct__f); } else { printf("Unable to read BME280 on pin %i\n", Spi_channel__i); } char buff[11]; int timeNow = 0; int c; while (1) { timeNow = (int)time(NULL); sprintf(buff, "%d", timeNow); myWeather->DeviceId = "raspy"; myWeather->EventTime = buff; if (Result__i == 1) { myWeather->MTemperature = Temp_C__f; printf("Humidity = %.1f%% Temperature = %.1f*C \n", Humidity_pct__f, Temp_C__f); } else { myWeather->MTemperature = 404.0; printf("Unable to read BME280 on pin %i\n", Spi_channel__i); pinMode(Red_led_pin__i, OUTPUT); } if (SERIALIZE(&destination, &destinationSize, myWeather->DeviceId, myWeather->EventTime, myWeather->MTemperature) != IOT_AGENT_OK) { (void)printf("Failed to serialize\r\n"); } else { sendMessage(iotHubClientHandle, destination, destinationSize); } delay(5000); } /* wait for commands */ // (void)getchar(); close_lockfile(Lock_fd__i); } DESTROY_MODEL_INSTANCE(myWeather); } IoTHubClient_Destroy(iotHubClientHandle); } serializer_deinit(); } }
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(); } }
void remote_monitoring_run(void) { initBme(); srand((unsigned int)time(NULL)); if (serializer_init(NULL) != SERIALIZER_OK) { LogInfo("Failed on serializer_init\r\n"); } else { IOTHUB_CLIENT_CONFIG config; IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle; config.deviceId = deviceId; config.deviceKey = deviceKey; config.iotHubName = hubName; config.iotHubSuffix = hubSuffix; config.protocol = HTTP_Protocol; iotHubClientHandle = IoTHubClient_LL_Create(&config); if (iotHubClientHandle == NULL) { LogInfo("Failed on IoTHubClient_CreateFromConnectionString\r\n"); } else { #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 Thermostat* thermostat = CREATE_MODEL_INSTANCE(Contoso, Thermostat); if (thermostat == NULL) { LogInfo("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { STRING_HANDLE commandsMetadata; if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, thermostat) != IOTHUB_CLIENT_OK) { LogInfo("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) { LogInfo("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) { LogInfo("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) { LogInfo("Failed serializing\r\n"); } else { sendMessage(iotHubClientHandle, buffer, bufferSize); } } STRING_delete(commandsMetadata); } thermostat->DeviceId = (char*)deviceId; int sendCycle = 10; int currentCycle = 0; while (1) { if(currentCycle >= sendCycle) { float Temp; float Humi; getNextSample(&Temp, &Humi); //thermostat->Temperature = 50 + (rand() % 10 + 2); thermostat->Temperature = (int)round(Temp); thermostat->ExternalTemperature = 55 + (rand() % 5 + 2); //thermostat->Humidity = 50 + (rand() % 8 + 2); thermostat->Humidity = (int)round(Humi); currentCycle = 0; unsigned char*buffer; size_t bufferSize; LogInfo("Sending sensor value Temperature = %d, Humidity = %d\r\n", thermostat->Temperature, thermostat->Humidity); if (SERIALIZE(&buffer, &bufferSize, thermostat->DeviceId, thermostat->Temperature, thermostat->Humidity, thermostat->ExternalTemperature) != IOT_AGENT_OK) { LogInfo("Failed sending sensor value\r\n"); } else { sendMessage(iotHubClientHandle, buffer, bufferSize); } } IoTHubClient_LL_DoWork(iotHubClientHandle); ThreadAPI_Sleep(100); currentCycle++; } } DESTROY_MODEL_INSTANCE(thermostat); } IoTHubClient_LL_Destroy(iotHubClientHandle); } serializer_deinit(); } }