void iothub_client_sample_http_run(void) { TRANSPORT_HANDLE httpTransport; IOTHUB_CLIENT_HANDLE iothubClient1; IOTHUB_CLIENT_HANDLE iothubClient2; EVENT_INSTANCE messages1[MESSAGE_COUNT]; EVENT_INSTANCE messages2[MESSAGE_COUNT]; double avgWindSpeed = 10.0; double minTemperature = 20.0; double minHumidity = 60.0; double temperature = 0; double humidity = 0; int receiveContext1 = 0; int receiveContext2 = 0; srand((unsigned int)time(NULL)); callbackCounter = 0; if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { (void)printf("Starting the IoTHub client sample HTTP with Shared connection...\r\n"); if ((httpTransport = IoTHubTransport_Create(HTTP_Protocol, hubName, hubSuffix)) == NULL) { (void)printf("ERROR: httpTransport is NULL\r\n"); } else { IOTHUB_CLIENT_CONFIG config1; config1.deviceId = deviceId1; config1.deviceKey = deviceKey1; config1.protocol = HTTP_Protocol; config1.iotHubName = NULL; config1.iotHubSuffix = NULL; config1.deviceSasToken = NULL; if ((iothubClient1 = IoTHubClient_CreateWithTransport(httpTransport, &config1)) == NULL) { (void)printf("ERROR: 1st device handle is NULL\r\n"); } else { IOTHUB_CLIENT_CONFIG config2; config2.deviceId = deviceId2; config2.deviceKey = deviceKey2; config2.protocol = HTTP_Protocol; config2.iotHubName = NULL; config2.iotHubSuffix = NULL; config2.deviceSasToken = NULL; if ((iothubClient2 = IoTHubClient_CreateWithTransport(httpTransport, &config2)) == NULL) { (void)printf("ERROR: 2nd device handle is NULL\r\n"); } else { unsigned int timeout = 241000; // Because it can poll "after 9 seconds" polls will happen effectively // at ~10 seconds. // Note that for scalabilty, the default value of minimumPollingTime // is 25 minutes. For more information, see: // https://azure.microsoft.com/documentation/articles/iot-hub-devguide/#messaging unsigned int minimumPollingTime = 9; iothub_client_sample_http_setoptions(iothubClient1, timeout, minimumPollingTime); iothub_client_sample_http_setoptions(iothubClient2, timeout, minimumPollingTime); // Setting message callbacks so we can receive commands if (IoTHubClient_SetMessageCallback(iothubClient1, ReceiveMessageCallback, &receiveContext1) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SetMessageCallback 1st device..........FAILED!\r\n"); } else { if (IoTHubClient_SetMessageCallback(iothubClient2, ReceiveMessageCallback, &receiveContext2) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_LL_SetMessageCallback 2nd device..........FAILED!\r\n"); } else { // Now that we are ready to receive commands, let's send some messages int i; (void)printf("IoTHubClient_LL_SetMessageCallback...successful.\r\n"); for (i = 0; i < MESSAGE_COUNT; i++) { temperature = minTemperature + (rand() % 10); humidity = minHumidity + (rand() % 20); sprintf_s(msgText, sizeof(msgText), "{\"deviceId\": \"%s\",\"windSpeed\":%.2f,\"temperature\":%.2f,\"humidity\":%.2f}", deviceId1, avgWindSpeed + (rand() % 4 + 2), temperature, humidity); iothub_client_sample_http_send_one_msg(iothubClient1, &messages1[i], i); temperature = minTemperature + (rand() % 10); humidity = minHumidity + (rand() % 20); sprintf_s(msgText, sizeof(msgText), "{\"deviceId\": \"%s\",\"windSpeed\":%.2f,\"temperature\":%.2f,\"humidity\":%.2f}", deviceId2, avgWindSpeed + (rand() % 4 + 2), temperature, humidity); iothub_client_sample_http_send_one_msg(iothubClient2, &messages2[i], i); } // Wait for any incoming messages (void)printf("Press any key to exit the application. \r\n"); (void)getchar(); } } IoTHubClient_Destroy(iothubClient2); } IoTHubClient_Destroy(iothubClient1); } IoTHubTransport_Destroy(httpTransport); } platform_deinit(); } }
void nodemcu_init(void) { NODE_ERR("\n"); // Initialize platform first for lua modules. if( platform_init() != PLATFORM_OK ) { // This should never happen NODE_DBG("Can not init platform for modules.\n"); return; } #if defined(FLASH_SAFE_API) if( flash_safe_get_size_byte() != flash_rom_get_size_byte()) { NODE_ERR("Self adjust flash size.\n"); // Fit hardware real flash size. flash_rom_set_size_byte(flash_safe_get_size_byte()); // Flash init data at FLASHSIZE - 0x04000 Byte. flash_init_data_default(); // Flash blank data at FLASHSIZE - 0x02000 Byte. flash_init_data_blank(); if( !fs_format() ) { NODE_ERR( "\ni*** ERROR ***: unable to format. FS might be compromised.\n" ); NODE_ERR( "It is advised to re-flash the NodeMCU image.\n" ); } else{ NODE_ERR( "format done.\n" ); } fs_unmount(); // mounted by format. } #endif // defined(FLASH_SAFE_API) if( !flash_init_data_written() ){ NODE_ERR("Restore init data.\n"); // Flash init data at FLASHSIZE - 0x04000 Byte. flash_init_data_default(); // Flash blank data at FLASHSIZE - 0x02000 Byte. flash_init_data_blank(); } #if defined( BUILD_WOFS ) romfs_init(); // if( !wofs_format() ) // { // NODE_ERR( "\ni*** ERROR ***: unable to erase the flash. WOFS might be compromised.\n" ); // NODE_ERR( "It is advised to re-flash the NodeWifi image.\n" ); // } // else // NODE_ERR( "format done.\n" ); // test_romfs(); #elif defined ( BUILD_SPIFFS ) fs_mount(); // test_spiffs(); #endif // endpoint_setup(); // char* lua_argv[] = { (char *)"lua", (char *)"-e", (char *)"print(collectgarbage'count');ttt={};for i=1,100 do table.insert(ttt,i*2 -1);print(i);end for k, v in pairs(ttt) do print('<'..k..' '..v..'>') end print(collectgarbage'count');", NULL }; // lua_main( 3, lua_argv ); // char* lua_argv[] = { (char *)"lua", (char *)"-i", NULL }; // lua_main( 2, lua_argv ); // char* lua_argv[] = { (char *)"lua", (char *)"-e", (char *)"pwm.setup(0,100,50) pwm.start(0) pwm.stop(0)", NULL }; // lua_main( 3, lua_argv ); // NODE_DBG("Flash sec num: 0x%x\n", flash_get_sec_num()); task_init(); system_os_post(USER_TASK_PRIO_0,SIG_LUA,'s'); }
/* C entry point for boot CPU */ void __init start_xen(unsigned long boot_phys_offset, unsigned long fdt_paddr, unsigned long cpuid) { size_t fdt_size; int cpus, i; const char *cmdline; setup_cache(); percpu_init_areas(); set_processor_id(0); /* needed early, for smp_processor_id() */ smp_clear_cpu_maps(); /* This is mapped by head.S */ device_tree_flattened = (void *)BOOT_FDT_VIRT_START + (fdt_paddr & ((1 << SECOND_SHIFT) - 1)); fdt_size = device_tree_early_init(device_tree_flattened, fdt_paddr); cmdline = device_tree_bootargs(device_tree_flattened); early_printk("Command line: %s\n", cmdline); cmdline_parse(cmdline); setup_pagetables(boot_phys_offset, get_xen_paddr()); setup_mm(fdt_paddr, fdt_size); vm_init(); dt_unflatten_host_device_tree(); dt_irq_xlate = gic_irq_xlate; dt_uart_init(); console_init_preirq(); system_state = SYS_STATE_boot; processor_id(); platform_init(); smp_init_cpus(); cpus = smp_get_max_cpus(); init_xen_time(); gic_init(); set_current((struct vcpu *)0xfffff000); /* debug sanity */ idle_vcpu[0] = current; init_traps(); setup_virt_paging(); p2m_vmid_allocator_init(); softirq_init(); tasklet_subsys_init(); init_IRQ(); gic_route_ppis(); gic_route_spis(); init_maintenance_interrupt(); init_timer_interrupt(); timer_init(); init_idle_domain(); rcu_init(); arch_init_memory(); local_irq_enable(); local_abort_enable(); smp_prepare_cpus(cpus); initialize_keytable(); console_init_postirq(); do_presmp_initcalls(); for_each_present_cpu ( i ) { if ( (num_online_cpus() < cpus) && !cpu_online(i) ) { int ret = cpu_up(i); if ( ret != 0 ) printk("Failed to bring up CPU %u (error %d)\n", i, ret); } } printk("Brought up %ld CPUs\n", (long)num_online_cpus()); /* TODO: smp_cpus_done(); */ do_initcalls(); /* Create initial domain 0. */ dom0 = domain_create(0, 0, 0); if ( IS_ERR(dom0) || (alloc_dom0_vcpu0() == NULL) ) panic("Error creating domain 0"); dom0->is_privileged = 1; dom0->target = NULL; if ( construct_dom0(dom0) != 0) panic("Could not set up DOM0 guest OS"); /* Scrub RAM that is still free and so may go to an unprivileged domain. */ scrub_heap_pages(); init_constructors(); console_endboot(); /* Hide UART from DOM0 if we're using it */ serial_endboot(); system_state = SYS_STATE_active; domain_unpause_by_systemcontroller(dom0); /* Switch on to the dynamically allocated stack for the idle vcpu * since the static one we're running on is about to be freed. */ memcpy(idle_vcpu[0]->arch.cpu_info, get_cpu_info(), sizeof(struct cpu_info)); switch_stack_and_jump(idle_vcpu[0]->arch.cpu_info, init_done); }
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; }
void qaas_mqtt_run(char param[]) { int count = 0; char macAdrs[18]; unsigned char* destination; size_t destinationSize; //getMACAddress(0, macAdrs); (void)printf("Mac Adress %s.\r\n", macAdrs); if (platform_init() != 0) { (void)printf("Failed on serializer_init\r\n"); } else { if (serializer_init(NULL) != SERIALIZER_OK) { (void)printf("Failed on serializer_init\r\n"); } else { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, MQTT_Protocol); srand((unsigned int)time(NULL)); int avgPrtclSize = 10; if (iotHubClientHandle == NULL) { (void)printf("Failed on IoTHubClient_LL_Create\r\n"); } else { CompostClient1* deviceInfo = CREATE_MODEL_INSTANCE(CompostClient, CompostClient1); if (deviceInfo == NULL) { (void)printf("Failed on CREATE_MODEL_INSTANCE\r\n"); } else { if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessage, deviceInfo) != IOTHUB_CLIENT_OK) { printf("unable to IoTHubClient_SetMessageCallback\r\n"); } else { deviceInfo->DeviceId = "CompClnt01"; /* wait for commands */ while (1) { deviceInfo->Height = measuredHeight; if(count%50 == 0) { if (SERIALIZE(&destination, &destinationSize, deviceInfo->DeviceId, deviceInfo->Height) != IOT_AGENT_OK) { (void)printf("Failed to serialize\r\n"); } else { IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(destination, destinationSize); if (messageHandle == NULL) { printf("unable to create a new IoTHubMessage\r\n"); } else { if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messageHandle, sendCallback, (void*)1) != IOTHUB_CLIENT_OK) { printf("failed to hand over the message to IoTHubClient"); } else { printf("IoTHubClient accepted the message for delivery\r\n"); } IoTHubMessage_Destroy(messageHandle); } free(destination); } } IoTHubClient_LL_DoWork(iotHubClientHandle); count++; //ThreadAPI_Sleep(SAMPLES_COUNT * SAMPLING_TIME * 1000); // secs ThreadAPI_Sleep(100); } } DESTROY_MODEL_INSTANCE(deviceInfo); } IoTHubClient_LL_Destroy(iotHubClientHandle); } serializer_deinit(); } platform_deinit(); } }
int main(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; }
/* C entry point for boot CPU */ void __init start_xen(unsigned long boot_phys_offset, unsigned long fdt_paddr, unsigned long cpuid) { size_t fdt_size; int cpus, i; paddr_t xen_paddr; const char *cmdline; struct bootmodule *xen_bootmodule; struct domain *dom0; struct xen_arch_domainconfig config; setup_cache(); percpu_init_areas(); set_processor_id(0); /* needed early, for smp_processor_id() */ set_current((struct vcpu *)0xfffff000); /* debug sanity */ idle_vcpu[0] = current; setup_virtual_regions(NULL, NULL); /* Initialize traps early allow us to get backtrace when an error occurred */ init_traps(); smp_clear_cpu_maps(); /* This is mapped by head.S */ device_tree_flattened = (void *)BOOT_FDT_VIRT_START + (fdt_paddr & ((1 << SECOND_SHIFT) - 1)); fdt_size = boot_fdt_info(device_tree_flattened, fdt_paddr); cmdline = boot_fdt_cmdline(device_tree_flattened); printk("Command line: %s\n", cmdline); cmdline_parse(cmdline); /* Register Xen's load address as a boot module. */ xen_bootmodule = add_boot_module(BOOTMOD_XEN, (paddr_t)(uintptr_t)(_start + boot_phys_offset), (paddr_t)(uintptr_t)(_end - _start + 1), NULL); BUG_ON(!xen_bootmodule); xen_paddr = get_xen_paddr(); setup_pagetables(boot_phys_offset, xen_paddr); /* Update Xen's address now that we have relocated. */ printk("Update BOOTMOD_XEN from %"PRIpaddr"-%"PRIpaddr" => %"PRIpaddr"-%"PRIpaddr"\n", xen_bootmodule->start, xen_bootmodule->start + xen_bootmodule->size, xen_paddr, xen_paddr + xen_bootmodule->size); xen_bootmodule->start = xen_paddr; setup_mm(fdt_paddr, fdt_size); /* Parse the ACPI tables for possible boot-time configuration */ acpi_boot_table_init(); end_boot_allocator(); vm_init(); dt_unflatten_host_device_tree(); init_IRQ(); platform_init(); preinit_xen_time(); gic_preinit(); arm_uart_init(); console_init_preirq(); console_init_ring(); system_state = SYS_STATE_boot; processor_id(); smp_init_cpus(); cpus = smp_get_max_cpus(); init_xen_time(); gic_init(); p2m_vmid_allocator_init(); softirq_init(); tasklet_subsys_init(); xsm_dt_init(); init_maintenance_interrupt(); init_timer_interrupt(); timer_init(); init_idle_domain(); rcu_init(); arch_init_memory(); local_irq_enable(); local_abort_enable(); smp_prepare_cpus(cpus); initialize_keytable(); console_init_postirq(); do_presmp_initcalls(); for_each_present_cpu ( i ) { if ( (num_online_cpus() < cpus) && !cpu_online(i) ) { int ret = cpu_up(i); if ( ret != 0 ) printk("Failed to bring up CPU %u (error %d)\n", i, ret); } } printk("Brought up %ld CPUs\n", (long)num_online_cpus()); /* TODO: smp_cpus_done(); */ setup_virt_paging(); iommu_setup(); do_initcalls(); /* * It needs to be called after do_initcalls to be able to use * stop_machine (tasklets initialized via an initcall). */ apply_alternatives_all(); /* Create initial domain 0. */ /* The vGIC for DOM0 is exactly emulating the hardware GIC */ config.gic_version = XEN_DOMCTL_CONFIG_GIC_NATIVE; config.nr_spis = gic_number_lines() - 32; dom0 = domain_create(0, 0, 0, &config); if ( IS_ERR(dom0) || (alloc_dom0_vcpu0(dom0) == NULL) ) panic("Error creating domain 0"); dom0->is_privileged = 1; dom0->target = NULL; if ( construct_dom0(dom0) != 0) panic("Could not set up DOM0 guest OS"); /* Scrub RAM that is still free and so may go to an unprivileged domain. */ scrub_heap_pages(); init_constructors(); console_endboot(); /* Hide UART from DOM0 if we're using it */ serial_endboot(); system_state = SYS_STATE_active; /* Must be done past setting system_state. */ unregister_init_virtual_region(); domain_unpause_by_systemcontroller(dom0); /* Switch on to the dynamically allocated stack for the idle vcpu * since the static one we're running on is about to be freed. */ memcpy(idle_vcpu[0]->arch.cpu_info, get_cpu_info(), sizeof(struct cpu_info)); switch_stack_and_jump(idle_vcpu[0]->arch.cpu_info, init_done); }
int main(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)); IOTHUB_CLIENT_TRANSPORT_PROVIDER protocol; #ifdef USE_HTTP protocol = HTTP_Protocol; #endif #ifdef USE_MQTT protocol = MQTT_Protocol; #endif #ifdef USE_AMQP protocol = AMQP_Protocol; #endif callbackCounter = 0; if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { (void)printf("Starting the IoTHub client sample x509...\r\n"); if ((iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, protocol)) == NULL) { (void)printf("ERROR: iotHubClientHandle is NULL!\r\n"); } else { #ifdef USE_HTTP if (protocol == HTTP_Protocol) { 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"); } } else #endif { bool trace = true; (void)IoTHubClient_LL_SetOption(iotHubClientHandle, "logtrace", &trace); } /*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); (void)sprintf_s(propText, sizeof(propText), "PropMsg_%zu", 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_x509 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(); } }
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 iothub_client_sample_amqp_run(void) { TRANSPORT_HANDLE transport_handle; IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle1; IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle2; EVENT_INSTANCE messages_device1[MESSAGE_COUNT]; EVENT_INSTANCE messages_device2[MESSAGE_COUNT]; g_continueRunning = true; //callbackCounter = 0; int receiveContext1 = 0; int receiveContext2 = 0; (void)printf("Starting the IoTHub client sample AMQP...\r\n"); if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { if ((transport_handle = IoTHubTransport_Create(AMQP_Protocol, hubName, hubSuffix)) == NULL) { printf("Failed to creating the protocol handle.\r\n"); } else { IOTHUB_CLIENT_DEVICE_CONFIG config1; config1.deviceId = deviceId1; config1.deviceKey = deviceKey1; config1.deviceSasToken = NULL; config1.protocol = AMQP_Protocol; config1.transportHandle = IoTHubTransport_GetLLTransport(transport_handle); IOTHUB_CLIENT_DEVICE_CONFIG config2; config2.deviceId = deviceId2; config2.deviceKey = deviceKey2; config2.deviceSasToken = NULL; config2.protocol = AMQP_Protocol; config2.transportHandle = IoTHubTransport_GetLLTransport(transport_handle); if ((iotHubClientHandle1 = IoTHubClient_LL_CreateWithTransport(&config1)) == NULL) { (void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n"); } else if ((iotHubClientHandle2 = IoTHubClient_LL_CreateWithTransport(&config2)) == NULL) { (void)printf("ERROR: iotHubClientHandle1 is NULL!\r\n"); } else { bool traceOn = true; IoTHubClient_LL_SetOption(iotHubClientHandle1, OPTION_LOG_TRACE, &traceOn); #ifdef SET_TRUSTED_CERT_IN_SAMPLES // For mbed add the certificate information if (IoTHubClient_LL_SetOption(iotHubClientHandle1, OPTION_TRUSTED_CERT, certificates) != IOTHUB_CLIENT_OK) { printf("failure to set option \"TrustedCerts\"\r\n"); } #endif // SET_TRUSTED_CERT_IN_SAMPLES if (create_events(messages_device1, config1.deviceId) != 0 || create_events(messages_device2, config2.deviceId) != 0) { (void)printf("ERROR: failed creating events for the devices..........FAILED!\r\n"); } /* Setting Message call back, so we can receive Commands. */ else if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle1, ReceiveMessageCallback, &receiveContext1) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SetMessageCallback for device 1..........FAILED!\r\n"); } else if (IoTHubClient_LL_SetMessageCallback(iotHubClientHandle2, ReceiveMessageCallback, &receiveContext2) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SetMessageCallback for device 2..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SetMessageCallback...successful.\r\n"); /* Now that we are ready to receive commands, let's send some messages */ size_t iterator = 0; do { if (iterator < MESSAGE_COUNT) { if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle1, messages_device1[iterator].messageHandle, SendConfirmationCallback, &messages_device1[iterator]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SendEventAsync for device 1..........FAILED!\r\n"); } else if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle2, messages_device2[iterator].messageHandle, SendConfirmationCallback, &messages_device2[iterator]) != IOTHUB_CLIENT_OK) { (void)printf("ERROR: IoTHubClient_SendEventAsync for device 2..........FAILED!\r\n"); } else { (void)printf("IoTHubClient_SendEventAsync accepted data for transmission to IoT Hub.\r\n"); } IoTHubMessage_Destroy(messages_device1[iterator].messageHandle); IoTHubMessage_Destroy(messages_device2[iterator].messageHandle); } IoTHubClient_LL_DoWork(iotHubClientHandle1); IoTHubClient_LL_DoWork(iotHubClientHandle2); ThreadAPI_Sleep(1); iterator++; } while (g_continueRunning); (void)printf("iothub_client_sample_mqtt has gotten quit message, call DoWork %d more time to complete final sending...\r\n", DOWORK_LOOP_NUM); for (size_t index = 0; index < DOWORK_LOOP_NUM; index++) { IoTHubClient_LL_DoWork(iotHubClientHandle1); ThreadAPI_Sleep(1); } } IoTHubClient_LL_Destroy(iotHubClientHandle1); IoTHubClient_LL_Destroy(iotHubClientHandle2); } IoTHubTransport_Destroy(transport_handle); } platform_deinit(); } }
/* ********* */ int main(int argc, char **argv) { int i, error; /* set exe */ session.exe = argv[0]; /* fetch program name, if we can */ for(i = 0; argv[0][i]; ++i) { if(argv[0][i] == '/' || argv[0][i] == '\\') session.name = &argv[0][i+1]; } /* parse environment parameters */ if(getenv("BAM_OPTIONS")) { if(parse_parameters_str(getenv("BAM_OPTIONS"))) return -1; } /* parse commandline parameters */ if(parse_parameters(argc-1, argv+1)) return -1; /* set eventlog */ if(option_win_msvcmode) session.win_msvcmode = option_win_msvcmode; /* init platform */ platform_init(); /* set eventlog */ if(option_debug_eventlog) { session.eventlog = fopen(option_debug_eventlog, "w"); session.eventlogflush = option_debug_eventlogflush; if(!session.eventlog) { printf("%s: error opening '%s' for output\n", session.name, option_debug_eventlog); return 1; } } /* parse the report str */ for(i = 0; option_report_str[i]; i++) { if(option_report_str[i] == 'c') session.report_color = 1; else if(option_report_str[i] == 'b') session.report_bar = 1; else if(option_report_str[i] == 's') session.report_steps = 1; } /* convert the threads string */ if(option_threads_str) { session.threads = atoi(option_threads_str); if(session.threads < 0) { printf("%s: invalid number of threads supplied\n", session.name); return 1; } } else { session.threads = threads_corecount(); if(session.verbose) printf("%s: detected %d cores\n", session.name, session.threads); } /* check for help argument */ if(option_print_debughelp) { print_help(OF_PRINT|OF_DEBUG); return 0; } else if(option_print_help) { print_help(OF_PRINT); return 0; } /* */ if(option_debug_dumpinternal) { int f; for(f = 0; internal_files[f].filename; f++) { printf("%s:\n", internal_files[f].filename); puts(internal_files[f].content); } return 0; } if(option_lua_execute) { struct lua_State* lua = lua_newstate(lua_alloctor_malloc, 0x0); lua_atpanic(lua, lf_panicfunc); /* register all functions */ if(register_lua_globals(lua, "script_dir", option_lua_execute) != 0) { printf("%s: error: registering of lua functions failed\n", session.name); return -1; } lua_getglobal(lua, "errorfunc"); switch(luaL_loadfile(lua, option_lua_execute)) { case 0: break; case LUA_ERRSYNTAX: lf_errorfunc(lua); return -1; case LUA_ERRMEM: printf("%s: memory allocation error\n", session.name); return -1; case LUA_ERRFILE: printf("%s: error opening '%s'\n", session.name, option_lua_execute); return -1; default: printf("%s: unknown error\n", session.name); return -1; } /* call the code chunk */ if(lua_pcall(lua, 0, LUA_MULTRET, -2) != 0) { printf("%s: script error (-t for more detail)\n", session.name); return -1; } lua_close(lua); error = 0; } else { /* init the context */ error = bam(option_script, option_targets, option_num_targets); } platform_shutdown(); /* error could be some high value like 256 seams like this could */ /* be clamped down to a unsigned char and not be an error anymore */ if(error) return 1; return 0; }
void device_twin_simple_sample_run(void) { /*prepare the platform*/ if (platform_init() != 0) { printf("Failed to initialize the platform.\n"); } else { if (SERIALIZER_REGISTER_NAMESPACE(Contoso) == NULL) { LogError("unable to SERIALIZER_REGISTER_NAMESPACE"); } else { /*create an IoTHub client*/ IOTHUB_CLIENT_HANDLE iotHubClientHandle = IoTHubClient_CreateFromConnectionString(connectionString, MQTT_Protocol); // Change to AMQP_Procotol if desired. if (iotHubClientHandle == NULL) { printf("Failure creating IoTHubClient handle"); } else { // Turn on Log bool trace = true; (void)IoTHubClient_SetOption(iotHubClientHandle, "logtrace", &trace); Car* car = IoTHubDeviceTwin_CreateCar(iotHubClientHandle); if (car == NULL) { printf("Failure in IoTHubDeviceTwin_CreateCar"); } else { /*setting values for reported properties*/ car->lastOilChangeDate = "2016"; car->maker.makerName = "Fabrikam"; car->maker.style = "sedan"; car->maker.year = 2014; car->state.reported_maxSpeed = 100; car->state.softwareVersion = 1; car->state.vanityPlate = "1I1"; // IoTHubDeviceTwin_SendReportedStateCar sends the reported status back to IoT Hub // to the associated device twin. // // IoTHubDeviceTwin_SendReportedStateCar is an auto-generated function, created // via the macro DECLARE_DEVICETWIN_MODEL(Car,...). It resolves to the underlying function // IoTHubDeviceTwin_SendReportedState_Impl(). if (IoTHubDeviceTwin_SendReportedStateCar(car, deviceTwinReportStateCallback, NULL) != IOTHUB_CLIENT_OK) { (void)printf("Failed sending serialized reported state\n"); } else { printf("Reported state will be send to IoTHub\n"); // Comment out the following three lines if you want to enable callback(s) for updates of the existing model (example: onDesiredMaxSpeed) if (IoTHubClient_SetDeviceTwinCallback(iotHubClientHandle, deviceTwinGetStateCallback, NULL) != IOTHUB_CLIENT_OK) { (void)printf("Failed subscribing for device twin properties\n"); } } printf("press ENTER to end the sample\n"); (void)getchar(); } IoTHubDeviceTwin_DestroyCar(car); } IoTHubClient_Destroy(iotHubClientHandle); } } platform_deinit(); }
PROCESS_THREAD(cetic_6lbr_process, ev, data) { PROCESS_BEGIN(); cetic_6lbr_startup = clock_seconds(); #if CONTIKI_TARGET_NATIVE slip_config_handle_arguments(contiki_argc, contiki_argv); if (watchdog_interval) { process_start(&native_6lbr_watchdog, NULL); } else { LOG6LBR_WARN("6LBR Watchdog disabled\n"); } #endif LOG6LBR_INFO("Starting 6LBR version " CETIC_6LBR_VERSION " (" CONTIKI_VERSION_STRING ")\n"); load_nvm_config(); platform_init(); process_start(ð_drv_process, NULL); while(!ethernet_ready) { PROCESS_PAUSE(); } //clean up any early packet uip_len = 0; process_start(&tcpip_process, NULL); PROCESS_PAUSE(); #if CETIC_NODE_INFO node_info_init(); #endif packet_filter_init(); cetic_6lbr_init(); #if WEBSERVER process_start(&webserver_nogui_process, NULL); #endif #if UDPSERVER process_start(&udp_server_process, NULL); #endif LOG6LBR_INFO("CETIC 6LBR Started\n"); #if CONTIKI_TARGET_NATIVE PROCESS_WAIT_EVENT(); etimer_set(&reboot_timer, CLOCK_SECOND); PROCESS_WAIT_EVENT(); switch (cetic_6lbr_restart_type) { case CETIC_6LBR_RESTART: LOG6LBR_INFO("Exiting...\n"); exit(0); break; case CETIC_6LBR_REBOOT: LOG6LBR_INFO("Rebooting...\n"); system("reboot"); break; case CETIC_6LBR_HALT: LOG6LBR_INFO("Halting...\n"); system("halt"); break; default: //We should never end up here... exit(1); } //We should never end up here... exit(1); #endif PROCESS_END(); }
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); (void)sprintf_s(propText, sizeof(propText), "PropMsg_%zu", 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(); } }
int main(void) { uint8_t tmp=0; int32_t ret = 0; uint8_t memsize[2][8] = {{2,2,2,2,2,2,2,2},{2,2,2,2,2,2,2,2}}; uint8_t txsize[8] = {2,2,2,2,2,2,2,2}; uint8_t rxsize[8] = {2,2,2,2,2,2,2,2}; uint8_t pDestaddr[4] = {192,168,0,200}; int8_t num; uint8_t ping_reply_received = 0; /////////////////////////////////////////// // Host dependent peripheral initialized // /////////////////////////////////////////// platform_init(); ////////// // TODO // //////////////////////////////////////////////////////////////////////////////////////////////////// // First of all, Should register SPI callback functions implemented by user for accessing WIZCHIP // //////////////////////////////////////////////////////////////////////////////////////////////////// /* Critical section callback - No use in this example */ //reg_wizchip_cris_cbfunc(0, 0); /* Chip selection call back */ #if _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_VDM_ reg_wizchip_cs_cbfunc(wizchip_select, wizchip_deselect); #elif _WIZCHIP_IO_MODE_ == _WIZCHIP_IO_MODE_SPI_FDM_ reg_wizchip_cs_cbfunc(wizchip_select, wizchip_select); // CS must be tried with LOW. #else #if (_WIZCHIP_IO_MODE_ & _WIZCHIP_IO_MODE_SIP_) != _WIZCHIP_IO_MODE_SIP_ #error "Unknown _WIZCHIP_IO_MODE_" #else reg_wizchip_cs_cbfunc(wizchip_select, wizchip_deselect); #endif #endif /* SPI Read & Write callback function */ reg_wizchip_spi_cbfunc(wizchip_read, wizchip_write); //////////////////////////////////////////////////////////////////////// /* WIZCHIP SOCKET Buffer initialize */ wizchip_init(txsize,rxsize); /* Network initialization */ network_init(); /*******************************/ /* WIZnet W5500 Code Examples */ /* TCPS/UDPS IPRAW test */ /*******************************/ printf("------------PING_TEST_START-----------------------\r\n"); tmp = ping_auto(0,pDestaddr); //tmp = ping_count(0,3,pDestaddr); if(tmp == SUCCESS) printf("-----------PING TEST OK----------\r\n"); else printf("----------ERROR = %d----------\r\n",tmp); } // end of main()
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(); } }
/* * Called when the instance of the TA is created. This is the first call in * the TA. */ TEE_Result TA_CreateEntryPoint(void) { platform_init(); return TEE_SUCCESS; }
int SendBatch_Sample(void) { int result; time_t t = time(&t); (void)printf("Starting the EventHub Client SendBatch Sample (%s)...\r\n", EventHubClient_GetVersionString() ); if (platform_init() != 0) { (void)printf("ERROR: Failed initializing platform!\r\n"); result = 1; } else { //Create an Array of EventData so we can send these data batched. EVENTDATA_HANDLE eventDataList[NUM_OF_MSG_TO_SEND]; size_t index; for (index = 0; index < NUM_OF_MSG_TO_SEND; index++) { char msgContent[BUFFER_SIZE]; size_t msgLength = sprintf_s(msgContent, BUFFER_SIZE, "{\"messageId\":%ul, \"timeValue\":%I64d, \"name\":\"SendBatch_Sample\"}", index, t); if ((eventDataList[index] = EventData_CreateWithNewMemory((const unsigned char*)msgContent, msgLength)) == NULL) { (void)printf("ERROR: EventData_CreateWithNewMemory returned NULL!\r\n"); result = 1; break; } } if (index == NUM_OF_MSG_TO_SEND) { EVENTHUBCLIENT_HANDLE eventHubClientHandle = EventHubClient_CreateFromConnectionString(connectionString, eventHubPath); if (eventHubClientHandle == NULL) { (void)printf("ERROR: EventHubClient_CreateFromConnectionString returned NULL!\r\n"); result = 1; } else { for (size_t i = 0; i < NUM_OF_MSG_TO_SEND; i++) { EventData_SetPartitionKey(eventDataList[i], PARTITION_KEY_INFO); } MAP_HANDLE mapProperties = EventData_Properties(eventDataList[0]); if (mapProperties != NULL) { if ((Map_AddOrUpdate(mapProperties, "SendBatch_HL_1", TEST_STRING_VALUE_1) != MAP_OK) || (Map_AddOrUpdate(mapProperties, "SendBatch_HL_2", TEST_STRING_VALUE_2) != MAP_OK) ) { (void)printf("ERROR: Map_AddOrUpdate failed!\r\n"); } } //Send all 3 data created above on the same call (Batched) if (EventHubClient_SendBatch(eventHubClientHandle, eventDataList, NUM_OF_MSG_TO_SEND) != EVENTHUBCLIENT_OK) { (void)printf("ERROR: EventHubClient_SendBatch failed!\r\n"); result = 1; } else { (void)printf("EventHubClient_SendBatch.......Successful\r\n"); result = 0; } EventHubClient_Destroy(eventHubClientHandle); } } for (size_t i = 0; i < index; i++) { EventData_Destroy(eventDataList[i]); } platform_init(); } return result; }
void GameManager::init() { #ifdef CHOWDREN_USER_PROFILER user_log.open("log.txt", "w"); #endif #ifdef CHOWDREN_USE_PROFILER PROFILE_SET_DAMPING(0.0); #endif frame = &static_frames; #ifdef CHOWDREN_IS_DEMO idle_timer_started = false; global_time = show_build_timer = reset_timer = manual_reset_timer = 0.0; #endif #ifdef CHOWDREN_USE_JOYTOKEY simulate_count = 0; axis_moved = false; last_axis = -1; deadzone = 0.4f; pad_selected = false; pad_disconnected = false; for (int i = 0; i < CHOWDREN_BUTTON_MAX-1; i++) key_mappings[i] = -1; for (int i = 0; i < CHOWDREN_AXIS_MAX-1; i++) { axis_pos_mappings[i] = -1; axis_neg_mappings[i] = -1; axis_values[i] = 0; } #endif platform_init(); media.init(); set_window(false); // application setup preload_images(); reset_globals(); setup_keys(this); // setup random generator from start cross_srand((unsigned int)platform_get_global_time()); fps_limit.start(); set_framerate(FRAMERATE); int start_frame = 0; #if defined(CHOWDREN_IS_AVGN) start_frame = 0; #elif defined(CHOWDREN_IS_HFA) start_frame = 0; #elif defined(CHOWDREN_IS_FP) player_died = false; lives = 3; start_frame = 0; // values->set(1, 2); // values->set(12, 2); #elif defined(CHOWDREN_IS_NAH) platform_set_scale_type(2); // start_frame = 3; // set_local("fre"); // values->set(13, 25); // strings->set(23, "OBJETS"); // strings->set(9, "-fre"); #else start_frame = 0; #endif #ifdef NDEBUG set_frame(0); #else set_frame(start_frame); #endif }
int main( void ) { int i; FILE* fp; // Initialize platform first if( platform_init() != PLATFORM_OK ) { // This should never happen while( 1 ); } // Initialize device manager dm_init(); // Register the ROM filesystem romfs_init(); // Register the MMC filesystem mmcfs_init(); // Register the Semihosting filesystem semifs_init(); // Register the remote filesystem remotefs_init(); // Register NIFFS nffs_init(); // Search for autorun files in the defined order and execute the 1st if found for( i = 0; i < sizeof( boot_order ) / sizeof( *boot_order ); i++ ) { if( ( fp = fopen( boot_order[ i ], "r" ) ) != NULL ) { fclose( fp ); char* lua_argv[] = { (char *)"lua", (char *)boot_order[i], NULL }; lua_main( 2, lua_argv ); break; // autoruns only the first found } } #ifdef ELUA_BOOT_RPC boot_rpc(); #else // Run the shell if( shell_init() == 0 ) { // Start Lua directly char* lua_argv[] = { (char *)"lua", NULL }; lua_main( 1, lua_argv ); } else shell_start(); #endif // #ifdef ELUA_BOOT_RPC #ifdef ELUA_SIMULATOR hostif_exit(0); return 0; #else while( 1 ); #endif }
int32 main(void) { #define TCP_LISTEN_PORT 5000 #define UDP_LISTEN_PORT 5000 int8 ret, root; uint32 dhcp_renew, dhcp_rebind, dhcp_time; uint32 dhcp_tick, led_tick; ret = platform_init(); if(ret != RET_OK) { goto FAIL_TRAP; } ret = network_init(SOCK_DHCP, NULL, NULL); if(ret != RET_OK) { ERRA("network_init fail - ret(%d)", ret); goto FAIL_TRAP; } printf("\r\n-----------------------------------\r\n"); printf("SMTP Client using W5200\r\n"); printf("-----------------------------------\r\n\r\n"); Delay_tick(2000); do { ret = dhcp_manual(DHCP_ACT_START, NULL, &dhcp_renew, &dhcp_rebind); } while(ret != RET_OK); dhcp_renew = wizpf_tick_conv(FALSE, dhcp_renew); dhcp_rebind = wizpf_tick_conv(FALSE, dhcp_rebind); dhcp_time = dhcp_renew; menu_init(); root = menu_add("Network setting", 0, NULL); menu_add("Show", root, mn_show_network); menu_add("Static Set", root, mn_set_network); menu_add("Loopback", 0, mn_loopback); menu_add("LED Test", 0, mn_set_led); root = menu_add("App Test", 0, NULL); menu_add("DNS", root, mn_dns); menu_add("BASE64", root, mn_base64); menu_add("eMail", root, mn_email); menu_print_tree(); dhcp_tick = led_tick = wizpf_get_systick(); while(1) { if(wizpf_tick_elapse(dhcp_tick) > dhcp_time) { if(dhcp_time==dhcp_renew) DBG("start renew"); else DBG("start rebind"); ret = dhcp_manual(dhcp_time==dhcp_renew? DHCP_ACT_RENEW: DHCP_ACT_REBIND, NULL, &dhcp_renew, &dhcp_rebind); dhcp_tick = wizpf_get_systick(); if(ret == RET_OK) { // renew success dhcp_renew = wizpf_tick_conv(FALSE, dhcp_renew); dhcp_rebind = wizpf_tick_conv(FALSE, dhcp_rebind); dhcp_time = dhcp_renew; } else { if(dhcp_time == dhcp_renew) dhcp_time = dhcp_rebind; // renew fail, so try rebind else dhcp_time = 60000; // retry after 1 min } } menu_run(); if(lb_tcp) loopback_tcps(7, (uint16)TCP_LISTEN_PORT); if(lb_udp) loopback_udp(7, (uint16)UDP_LISTEN_PORT); if(wizpf_tick_elapse(led_tick) > 1000) { wizpf_led_set(WIZ_LED3, VAL_TOG); led_tick = wizpf_get_systick(); } } FAIL_TRAP: wizpf_led_trap(1); return 0; }
static int jiveL_initSDL(lua_State *L) { const SDL_VideoInfo *video_info; #ifndef JIVE_NO_DISPLAY JiveSurface *srf, *splash; Uint16 splash_w, splash_h; bool fullscreen = false; char splashfile[32] = "jive/splash.png"; #endif /* logging */ log_ui_draw = LOG_CATEGORY_GET("squeezeplay.ui.draw"); log_ui = LOG_CATEGORY_GET("squeezeplay.ui"); /* linux fbcon does not need a mouse */ SDL_putenv("SDL_NOMOUSE=1"); #ifdef JIVE_NO_DISPLAY # define JIVE_SDL_FEATURES (SDL_INIT_EVENTLOOP) #else # define JIVE_SDL_FEATURES (SDL_INIT_VIDEO) #endif /* initialise SDL */ if (SDL_Init(JIVE_SDL_FEATURES) < 0) { LOG_ERROR(log_ui_draw, "SDL_Init(V|T|A): %s\n", SDL_GetError()); SDL_Quit(); exit(-1); } /* report video info */ if ((video_info = SDL_GetVideoInfo())) { LOG_INFO(log_ui_draw, "%d,%d %d bits/pixel %d bytes/pixel [R<<%d G<<%d B<<%d]", video_info->current_w, video_info->current_h, video_info->vfmt->BitsPerPixel, video_info->vfmt->BytesPerPixel, video_info->vfmt->Rshift, video_info->vfmt->Gshift, video_info->vfmt->Bshift); LOG_INFO(log_ui_draw, "Hardware acceleration %s available", video_info->hw_available?"is":"is not"); LOG_INFO(log_ui_draw, "Window Manager %s available", video_info->wm_available?"is":"is not"); } /* Register callback for additional events (used for multimedia keys)*/ SDL_EventState(SDL_SYSWMEVENT,SDL_ENABLE); SDL_SetEventFilter(filter_events); // Secific magic for windows|linux|macos platform_init(L); #ifndef JIVE_NO_DISPLAY /* open window */ SDL_WM_SetCaption("SqueezePlay", "SqueezePlay"); SDL_ShowCursor(SDL_DISABLE); SDL_EnableKeyRepeat (100, 100); SDL_EnableUNICODE(1); #ifdef SCREEN_ROTATION_ENABLED screen_w = video_info->current_h; screen_h = video_info->current_w; #else screen_w = video_info->current_w; screen_h = video_info->current_h; #endif screen_bpp = video_info->vfmt->BitsPerPixel; if (video_info->wm_available) { /* desktop build */ JiveSurface *icon; /* load the icon */ icon = jive_surface_load_image("jive/app.png"); if (icon) { jive_surface_set_wm_icon(icon); jive_surface_free(icon); } splash = jive_surface_load_image(splashfile); if (splash) { jive_surface_get_size(splash, &splash_w, &splash_h); screen_w = splash_w; screen_h = splash_h; } } else { /* product build and full screen...*/ sprintf(splashfile, "jive/splash%dx%d.png", screen_w, screen_h); splash = jive_surface_load_image(splashfile); if(!splash) { sprintf(splashfile,"jive/splash.png"); splash = jive_surface_load_image(splashfile); } if (splash) { jive_surface_get_size(splash, &splash_w, &splash_h); } fullscreen = true; } srf = jive_surface_set_video_mode(screen_w, screen_h, screen_bpp, fullscreen); if (!srf) { LOG_ERROR(log_ui_draw, "Video mode not supported: %dx%d\n", screen_w, screen_h); SDL_Quit(); exit(-1); } if (splash) { jive_surface_blit(splash, srf, (screen_w - splash_w) > 0 ?((screen_w - splash_w) / 2):0, (screen_w - splash_w) > 0 ?((screen_w - splash_w) / 2):0); jive_surface_flip(srf); LOG_INFO(log_ui_draw, "Splash %s %dx%d Screen %dx%d", splashfile,splash_w,splash_h,screen_w,screen_h); } lua_getfield(L, 1, "screen"); if (lua_isnil(L, -1)) { LOG_ERROR(log_ui_draw, "no screen table"); SDL_Quit(); exit(-1); } /* store screen surface */ tolua_pushusertype(L, srf, "Surface"); lua_setfield(L, -2, "surface"); lua_getfield(L, -1, "bounds"); lua_pushinteger(L, screen_w); lua_rawseti(L, -2, 3); lua_pushinteger(L, screen_h); lua_rawseti(L, -2, 4); lua_pop(L, 2); /* background image */ jive_background = jive_tile_fill_color(0x000000FF); /* jive.ui.style = {} */ lua_getglobal(L, "jive"); lua_getfield(L, -1, "ui"); lua_newtable(L); lua_setfield(L, -2, "style"); lua_pop(L, 2); ui_watchdog = watchdog_get(); watchdog_keepalive(ui_watchdog, 6); /* 60 seconds to start */ #endif /* JIVE_NO_DISPLAY */ return 0; }
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.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; (void)printf("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) { (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(); } platform_deinit(); } }
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; 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 { #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_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++) { 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; MAP_HANDLE propMap = IoTHubMessage_Properties(messages[i].messageHandle); sprintf_s(propText, sizeof(propText), "PropMsg_%d", i); if (Map_AddOrUpdate(propMap, "PropName", 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(); } }
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(); } }
int main(int ac, char *av[]) { FILE *fin, *fout; int i; char *outfile; /* platform-specific initializations, e.g., set file i/o to binary */ platform_init(); /* process options */ dopts(ac, av); /* there are several ways to call us: mkbitmap -- stdin to stdout mkbitmap -o outfile -- stdin to outfile mkbitmap file... -- encode each file and generate outfile names mkbitmap file... -o outfile -- concatenate files and write to outfile */ if (info.infilecount == 0 && info.outfile == NULL) { /* stdin to stdout */ process_file(stdin, stdout, "stdin", "stdout"); return 0; } else if (info.infilecount == 0) { /* stdin to outfile */ fout = my_fopen_write(info.outfile); if (!fout) { fprintf(stderr, "mkbitmap: %s: %s\n", info.outfile, strerror(errno)); exit(2); } process_file(stdin, fout, "stdin", info.outfile); my_fclose(fout, info.outfile); free(info.outfile); return 0; } else if (info.outfile == NULL) { /* infiles -> multiple outfiles */ for (i=0; i<info.infilecount; i++) { outfile = make_outfilename(info.infiles[i], info.outext); if (!outfile) { fprintf(stderr, "mkbitmap: %s\n", strerror(errno)); exit(2); } fin = my_fopen_read(info.infiles[i]); if (!fin) { fprintf(stderr, "mkbitmap: %s: %s\n", info.infiles[i], strerror(errno)); exit(2); } fout = my_fopen_write(outfile); if (!fout) { fprintf(stderr, "mkbitmap: %s: %s\n", outfile, strerror(errno)); exit(2); } process_file(fin, fout, info.infiles[i], outfile); my_fclose(fin, info.infiles[i]); my_fclose(fout, outfile); free(outfile); } return 0; } else { /* infiles to single outfile */ fout = my_fopen_write(info.outfile); if (!fout) { fprintf(stderr, "mkbitmap: %s: %s\n", info.outfile, strerror(errno)); exit(2); } for (i=0; i<info.infilecount; i++) { fin = my_fopen_read(info.infiles[i]); if (!fin) { fprintf(stderr, "mkbitmap: %s: %s\n", info.infiles[i], strerror(errno)); exit(2); } process_file(fin, fout, info.infiles[i], info.outfile); my_fclose(fin, info.infiles[i]); } my_fclose(fout, info.outfile); free(info.outfile); return 0; } /* not reached */ }
int main(int ac, char *av[]) { backend_t *b; /* backend info */ FILE *fin, *fout; int i; char *outfile; /* platform-specific initializations, e.g., set file i/o to binary */ platform_init(); /* process options */ dopts(ac, av); b = info.backend; if (b==NULL) { fprintf(stderr, ""POTRACE": internal error: selected backend not found\n"); exit(1); } /* fix some parameters */ /* if backend cannot handle opticurve, disable it */ if (b->opticurve == 0) { info.param->opticurve = 0; } /* there are several ways to call us: potrace -- stdin to stdout potrace -o outfile -- stdin to outfile potrace file... -- encode each file and generate outfile names potrace -o outfile file... -- concatenate files and write to outfile The latter form is only allowed one file for single-page backends. For multi-page backends, each file must contain 0 or more complete bitmaps. */ if (!info.some_infiles) { /* read from stdin */ fout = my_fopen_write(info.outfile); if (!fout) { fprintf(stderr, ""POTRACE": %s: %s\n", info.outfile ? info.outfile : "stdout", strerror(errno)); exit(2); } if (b->init_f) { TRY(b->init_f(fout)); } process_file(b, "stdin", info.outfile ? info.outfile : "stdout", stdin, fout); if (b->term_f) { TRY(b->term_f(fout)); } my_fclose(fout, info.outfile); free(info.outfile); potrace_param_free(info.param); return 0; } else if (!info.outfile) { /* infiles -> multiple outfiles */ for (i=0; i<info.infilecount; i++) { outfile = make_outfilename(info.infiles[i], b->ext); if (!outfile) { fprintf(stderr, ""POTRACE": %s\n", strerror(errno)); exit(2); } fin = my_fopen_read(info.infiles[i]); if (!fin) { fprintf(stderr, ""POTRACE": %s: %s\n", info.infiles[i], strerror(errno)); exit(2); } fout = my_fopen_write(outfile); if (!fout) { fprintf(stderr, ""POTRACE": %s: %s\n", outfile, strerror(errno)); exit(2); } if (b->init_f) { TRY(b->init_f(fout)); } process_file(b, info.infiles[i], outfile, fin, fout); if (b->term_f) { TRY(b->term_f(fout)); } my_fclose(fin, info.infiles[i]); my_fclose(fout, outfile); free(outfile); } potrace_param_free(info.param); return 0; } else { /* infiles to single outfile */ if (!b->multi && info.infilecount >= 2) { fprintf(stderr, ""POTRACE": cannot use multiple input files with -o in %s mode\n", b->name); exit(1); } if (info.infilecount == 0) { fprintf(stderr, ""POTRACE": cannot use empty list of input files with -o\n"); exit(1); } fout = my_fopen_write(info.outfile); if (!fout) { fprintf(stderr, ""POTRACE": %s: %s\n", info.outfile, strerror(errno)); exit(2); } if (b->init_f) { TRY(b->init_f(fout)); } for (i=0; i<info.infilecount; i++) { fin = my_fopen_read(info.infiles[i]); if (!fin) { fprintf(stderr, ""POTRACE": %s: %s\n", info.infiles[i], strerror(errno)); exit(2); } process_file(b, info.infiles[i], info.outfile, fin, fout); my_fclose(fin, info.infiles[i]); } if (b->term_f) { TRY(b->term_f(fout)); } my_fclose(fout, info.outfile); free(info.outfile); potrace_param_free(info.param); return 0; } /* not reached */ try_error: fprintf(stderr, ""POTRACE": %s\n", strerror(errno)); exit(2); }
void iothub_client_sample_http_run(void) { IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle; EVENT_INSTANCE messages[MESSAGE_COUNT]; double avgWindSpeed = 10.0; int receiveContext = 0; srand((unsigned int)time(NULL)); callbackCounter = 0; if (platform_init() != 0) { printf("Failed to initialize the platform.\r\n"); } else { (void)printf("Starting the IoTHub client sample HTTP...\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"); } #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 { int i; (void)printf("IoTHubClient_LL_SetMessageCallback...successful.\r\n"); /* Now that we are ready to receive commands, let's send some messages */ for (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 { MAP_HANDLE propMap; messages[i].messageTrackingId = i; propMap = IoTHubMessage_Properties(messages[i].messageHandle); sprintf_s(propText, sizeof(propText), "PropMsg_%d", i); if (Map_AddOrUpdate(propMap, "PropName", propText) != MAP_OK) { (void)printf("ERROR: Map_AddOrUpdate Failed!\r\n"); } 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", i); } } } } /* Wait for Commands. */ while (1) { IoTHubClient_LL_DoWork(iotHubClientHandle); } IoTHubClient_LL_Destroy(iotHubClientHandle); } platform_deinit(); } }
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; }
int main(int argc, char** argv) { if (argc < 2) err("usage : ./obj portno"); int sfd[P]; int i, nsfd, fd = -1; int port = atoi(argv[1]); char buf[M]; fd_set master, test; FD_ZERO(&master); FD_ZERO(&test); shared_init(); platform_init(port); for (i = 0; i < P; i++) { sfd[i] = tcpsocket_bind(port + i); printf("Station %d listening on port : %d\n", i, port + i); if (fd < sfd[i]) fd = sfd[i]; FD_SET(sfd[i], &master); } while (1) { test = master; select(fd + 1, &test, NULL, NULL, NULL); for (i = 0; i < P; i++) { if (FD_ISSET(sfd[i], &test)) { nsfd = tcp_accept(sfd[i]); break; } } if (i != P) { printf("Train arrived on station - %d\n", i); for (i = 0; i < P; i++) { if (available(i)) { printf("Platform %d is available\n", i + 1); sprintf(buf, "%d", port + P + i); write(nsfd, buf, M); sleep(1); sprintf(buf, "pkill -SIGUSR1 p%d", i + 1); system(buf); break; } } if (i == P) { write(nsfd, "-1", 2); } close(nsfd); } } }