int main(int argc, char * argv[]) { mct_module_t *stats_module = NULL; mct_pipeline_cap_t query_buf; mct_event_t event; uint32_t i = 0; cam_stream_info_t stream_info; mct_port_t *stats_port = NULL; uint32_t identity = 0; /* Call mct module init */ stats_module = stats_module_init("stats"); if (!stats_module) { CDBG("%s: stats_module is Null\n", __func__); return -1; } /* Pack identity Session = 1 stream = 0*/ identity = pack_identity(1, 0); /* Call set mod */ stats_module->set_mod(stats_module, MCT_MODULE_FLAG_SINK, identity); if (!stats_module->process_event) { CDBG("%s: process event is Null\n", __func__); return -1; } stats_port = MCT_PORT_CAST(MCT_MODULE_SRCPORTS(stats_module)->data); if (!stats_port) { CDBG("%s: stats_port is Null\n", __func__); return -1; } stats_port->ext_link(identity, stats_port, NULL); /* Call Set parameter */ event.identity = identity; event.direction = MCT_EVENT_DOWNSTREAM; event.type = MCT_EVENT_CONTROL_CMD; /* From MCT */ event.u.ctrl_event.type = MCT_EVENT_CONTROL_SET_PARM; stream_info.stream_type = CAM_STREAM_TYPE_PREVIEW; event.u.ctrl_event.control_event_data = (void *)&stream_info; stats_module->process_event(stats_module, &event); /* Send STATS event */ event.identity = identity; event.direction = MCT_EVENT_DOWNSTREAM; event.type = MCT_EVENT_MODULE_EVENT; /* From ISP module */ event.u.ctrl_event.type = MCT_EVENT_MODULE_STATS_DATA; stats_module->process_event(stats_module, &event); stats_port->un_link(identity, stats_port, NULL); /* Deinit stats mct module */ stats_module_deinit(stats_module); return 0; }
/** * main * * The main function for the project. This function initializes the os, calls * init_tasks to initialize tasks (and possibly other objects), then starts the * OS. We should not return from os start. * * @return int NOTE: this function should never return! */ int main(int argc, char **argv) { int rc; #ifdef ARCH_sim mcu_sim_parse_args(argc, argv); #endif conf_init(); log_init(); log_console_handler_init(&log_console_handler); log_register("log", &my_log, &log_console_handler); LOG_DEBUG(&my_log, LOG_MODULE_DEFAULT, "bla"); LOG_DEBUG(&my_log, LOG_MODULE_DEFAULT, "bab"); os_init(); rc = os_mempool_init(&default_mbuf_mpool, DEFAULT_MBUF_MPOOL_NBUFS, DEFAULT_MBUF_MPOOL_BUF_LEN, default_mbuf_mpool_data, "default_mbuf_data"); assert(rc == 0); rc = os_mbuf_pool_init(&default_mbuf_pool, &default_mbuf_mpool, DEFAULT_MBUF_MPOOL_BUF_LEN, DEFAULT_MBUF_MPOOL_NBUFS); assert(rc == 0); rc = os_msys_register(&default_mbuf_pool); assert(rc == 0); shell_task_init(SHELL_TASK_PRIO, shell_stack, SHELL_TASK_STACK_SIZE, SHELL_MAX_INPUT_LEN); (void) console_init(shell_console_rx_cb); stats_module_init(); rc = init_tasks(); os_start(); /* os start should never return. If it does, this should be an error */ assert(0); return rc; }
/** * main * * The main function for the project. This function initializes the os, calls * init_tasks to initialize tasks (and possibly other objects), then starts the * OS. We should not return from os start. * * @return int NOTE: this function should never return! */ int main(void) { int i; int rc; int cnt; uint32_t seed; struct nffs_area_desc descs[NFFS_AREA_MAX]; /* Initialize OS */ os_init(); /* Set cputime to count at 1 usec increments */ rc = cputime_init(1000000); assert(rc == 0); rc = os_mempool_init(&g_mbuf_mempool, MBUF_NUM_MBUFS, MBUF_MEMBLOCK_SIZE, &g_mbuf_buffer[0], "mbuf_pool"); assert(rc == 0); rc = os_mbuf_pool_init(&g_mbuf_pool, &g_mbuf_mempool, MBUF_MEMBLOCK_SIZE, MBUF_NUM_MBUFS); assert(rc == 0); rc = os_msys_register(&g_mbuf_pool); assert(rc == 0); /* Dummy device address */ #if BLETEST_CFG_ROLE == BLETEST_ROLE_ADVERTISER g_dev_addr[0] = 0x00; g_dev_addr[1] = 0x00; g_dev_addr[2] = 0x00; g_dev_addr[3] = 0x88; g_dev_addr[4] = 0x88; g_dev_addr[5] = 0x08; g_bletest_cur_peer_addr[0] = 0x00; g_bletest_cur_peer_addr[1] = 0x00; g_bletest_cur_peer_addr[2] = 0x00; g_bletest_cur_peer_addr[3] = 0x99; g_bletest_cur_peer_addr[4] = 0x99; g_bletest_cur_peer_addr[5] = 0x09; #else g_dev_addr[0] = 0x00; g_dev_addr[1] = 0x00; g_dev_addr[2] = 0x00; g_dev_addr[3] = 0x99; g_dev_addr[4] = 0x99; g_dev_addr[5] = 0x09; g_bletest_cur_peer_addr[0] = 0x00; g_bletest_cur_peer_addr[1] = 0x00; g_bletest_cur_peer_addr[2] = 0x00; g_bletest_cur_peer_addr[3] = 0x88; g_bletest_cur_peer_addr[4] = 0x88; g_bletest_cur_peer_addr[5] = 0x08; #endif /* * Seed random number generator with least significant bytes of device * address. */ seed = 0; for (i = 0; i < 4; ++i) { seed |= g_dev_addr[i]; seed <<= 8; } srand(seed); /* Set the led pin as an output */ g_led_pin = LED_BLINK_PIN; gpio_init_out(g_led_pin, 1); /* Init the console */ rc = console_init(shell_console_rx_cb); assert(rc == 0); rc = hal_flash_init(); assert(rc == 0); nffs_config.nc_num_inodes = 32; nffs_config.nc_num_blocks = 64; nffs_config.nc_num_files = 2; nffs_config.nc_num_dirs = 2; rc = nffs_init(); assert(rc == 0); cnt = NFFS_AREA_MAX; rc = flash_area_to_nffs_desc(FLASH_AREA_NFFS, &cnt, descs); assert(rc == 0); if (nffs_detect(descs) == FS_ECORRUPT) { rc = nffs_format(descs); assert(rc == 0); } shell_task_init(SHELL_TASK_PRIO, shell_stack, SHELL_TASK_STACK_SIZE, SHELL_MAX_INPUT_LEN); nmgr_task_init(NEWTMGR_TASK_PRIO, newtmgr_stack, NEWTMGR_TASK_STACK_SIZE); imgmgr_module_init(); /* Init statistics module */ stats_module_init(); /* Init tasks */ init_tasks(); /* Start the OS */ os_start(); /* os start should never return. If it does, this should be an error */ assert(0); return rc; }
/** * Initializes the host portion of the BLE stack. */ int ble_hs_init(struct os_eventq *app_evq, struct ble_hs_cfg *cfg) { int rc; ble_hs_free_mem(); if (app_evq == NULL) { rc = BLE_HS_EINVAL; goto err; } ble_hs_parent_evq = app_evq; ble_hs_cfg_init(cfg); log_init(); log_console_handler_init(&ble_hs_log_console_handler); log_register("ble_hs", &ble_hs_log, &ble_hs_log_console_handler); ble_hs_hci_cmd_buf = malloc(OS_MEMPOOL_BYTES(ble_hs_cfg.max_hci_bufs, HCI_CMD_BUF_SIZE)); if (ble_hs_hci_cmd_buf == NULL) { rc = BLE_HS_ENOMEM; goto err; } /* Create memory pool of command buffers */ rc = os_mempool_init(&g_hci_cmd_pool, ble_hs_cfg.max_hci_bufs, HCI_CMD_BUF_SIZE, ble_hs_hci_cmd_buf, "HCICmdPool"); assert(rc == 0); ble_hs_hci_os_event_buf = malloc(OS_MEMPOOL_BYTES(ble_hs_cfg.max_hci_bufs, HCI_OS_EVENT_BUF_SIZE)); if (ble_hs_hci_os_event_buf == NULL) { rc = BLE_HS_ENOMEM; goto err; } /* Create memory pool of OS events */ rc = os_mempool_init(&g_hci_os_event_pool, ble_hs_cfg.max_hci_bufs, HCI_OS_EVENT_BUF_SIZE, ble_hs_hci_os_event_buf, "HCIOsEventPool"); assert(rc == 0); /* Initialize eventq */ os_eventq_init(&ble_hs_evq); /* Initialize stats. */ rc = stats_module_init(); if (rc != 0) { rc = BLE_HS_EOS; goto err; } ble_hci_cmd_init(); rc = ble_hs_conn_init(); if (rc != 0) { goto err; } rc = ble_l2cap_init(); if (rc != 0) { goto err; } rc = ble_att_init(); if (rc != 0) { goto err; } rc = ble_att_svr_init(); if (rc != 0) { goto err; } rc = ble_gap_init(); if (rc != 0) { goto err; } rc = ble_gattc_init(); if (rc != 0) { goto err; } rc = ble_gatts_init(); if (rc != 0) { goto err; } os_mqueue_init(&ble_hs_rx_q, NULL); os_mqueue_init(&ble_hs_tx_q, NULL); rc = stats_init_and_reg( STATS_HDR(ble_hs_stats), STATS_SIZE_INIT_PARMS(ble_hs_stats, STATS_SIZE_32), STATS_NAME_INIT_PARMS(ble_hs_stats), "ble_hs"); if (rc != 0) { rc = BLE_HS_EOS; goto err; } os_callout_func_init(&ble_hs_heartbeat_timer, ble_hs_parent_evq, ble_hs_heartbeat, NULL); os_callout_func_init(&ble_hs_event_co, &ble_hs_evq, ble_hs_event_handle, NULL); rc = os_mutex_init(&ble_hs_mutex); if (rc != 0) { rc = BLE_HS_EOS; goto err; } return 0; err: ble_hs_free_mem(); return rc; }