/** * Unit test's main function. */ int main (int __attr_unused___ argc, char __attr_unused___ **argv) { TEST_INIT (); const bytecode_data_header_t *bytecode_data_p; jsp_status_t parse_status; mem_init (); // #1 char program1[] = "a=1;var a;"; serializer_init (); parser_set_show_instrs (true); parse_status = parser_parse_script ((jerry_api_char_t *) program1, strlen (program1), &bytecode_data_p); JERRY_ASSERT (parse_status == JSP_STATUS_OK && bytecode_data_p != NULL); vm_instr_t instrs[] = { getop_meta (OPCODE_META_TYPE_SCOPE_CODE_FLAGS, // [ ] OPCODE_SCOPE_CODE_FLAGS_NOT_REF_ARGUMENTS_IDENTIFIER | OPCODE_SCOPE_CODE_FLAGS_NOT_REF_EVAL_IDENTIFIER, VM_IDX_EMPTY), getop_reg_var_decl (VM_REG_FIRST, VM_REG_GENERAL_FIRST, 0), getop_var_decl (0), // var a; getop_assignment (130, 1, 1), // $tmp0 = 1; getop_assignment (0, 6, 130), // a = $tmp0; getop_ret () // return; }; JERRY_ASSERT (instrs_equal (bytecode_data_p->instrs_p, instrs, 5)); serializer_free (); // #2 char program2[] = "var var;"; serializer_init (); parser_set_show_instrs (true); parse_status = parser_parse_script ((jerry_api_char_t *) program2, strlen (program2), &bytecode_data_p); JERRY_ASSERT (parse_status == JSP_STATUS_SYNTAX_ERROR && bytecode_data_p == NULL); serializer_free (); mem_finalize (false); return 0; } /* main */
static void dump_module(struct pimp_module *mod, const char *filename) { FILE *fp = NULL; struct serializer s; ASSERT(NULL != mod); /* open target file */ fp = fopen(filename, "wb"); if (NULL == fp) { perror(filename); exit(EXIT_FAILURE); } /* serialize module to memory dump */ serializer_init(&s); serialize_module(&s, mod); serializer_fixup_pointers(&s); fwrite(s.data, 1, s.pos, fp); /* close target file */ fclose(fp); fp = NULL; /* get rid of serializer */ serializer_deinit(&s); }
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(); } }
int main(int argc, char *argv[]) { FILE *fp = NULL; int i; int modules_loaded; int dither = 0; const char *sample_bank_fn = "sample_bank.bin"; struct pimp_sample_bank master_sample_bank; struct serializer s; pimp_sample_bank_init(&master_sample_bank); serializer_init(&s); modules_loaded = 0; for (i = 1; i < argc; ++i) { const char *arg = argv[i]; if (arg[0] == '-') { if (strlen(arg) < 2) print_usage(); switch (arg[1]) { case 'd': case 'D': dither = 1; break; default: print_usage(); } } else { struct pimp_module *mod; const char *ifn = arg; struct pimp_sample_bank sample_bank; pimp_sample_bank_init(&sample_bank); /* load module */ if (isatty(STDOUT_FILENO)) printf("loading %s...\n", ifn); mod = load_module(ifn, &sample_bank); if (NULL != mod) { char ofn[256]; modules_loaded++; /* generate output filename */ strncpy(ofn, ifn, 256); strncat(ofn, ".bin", 256); /* dump sample data */ merge_samples(&master_sample_bank, &sample_bank, mod); /* dump module */ if (isatty(STDOUT_FILENO)) printf("dumping %s...\n", ofn); dump_module(mod, ofn); } } } if (0 == modules_loaded) { fprintf(stderr, "%s: No input files\n", argv[0]); exit(EXIT_FAILURE); } if (isatty(STDOUT_FILENO)) printf("dumping %s\n", sample_bank_fn); fp = fopen(sample_bank_fn, "wb"); if (NULL == fp) { perror(sample_bank_fn); exit(EXIT_FAILURE); } fwrite(master_sample_bank.data, 1, master_sample_bank.size, fp); fclose(fp); fp = NULL; serializer_deinit(&s); return 0; }
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(); } }