static void h5_init(void) { BT_DBG(""); h5.link_state = UNINIT; h5.rx_state = START; h5.tx_win = 4; /* TX thread */ k_fifo_init(&h5.tx_queue); k_thread_create(&tx_thread_data, tx_stack, K_THREAD_STACK_SIZEOF(tx_stack), (k_thread_entry_t)tx_thread, NULL, NULL, NULL, K_PRIO_COOP(CONFIG_BT_HCI_TX_PRIO), 0, K_NO_WAIT); k_fifo_init(&h5.rx_queue); k_thread_create(&rx_thread_data, rx_stack, K_THREAD_STACK_SIZEOF(rx_stack), (k_thread_entry_t)rx_thread, NULL, NULL, NULL, K_PRIO_COOP(CONFIG_BT_RX_PRIO), 0, K_NO_WAIT); /* Unack queue */ k_fifo_init(&h5.unack_queue); /* Init delayed work */ k_delayed_work_init(&ack_work, ack_timeout); k_delayed_work_init(&retx_work, retx_timeout); }
void test_priority_preemptible(void) { int old_prio = k_thread_priority_get(k_current_get()); /* set current thread to a non-negative priority */ last_prio = 2; k_thread_priority_set(k_current_get(), last_prio); int spawn_prio = last_prio - 1; k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, thread_entry, NULL, NULL, NULL, spawn_prio, 0, 0); /* checkpoint: thread is preempted by higher thread */ zassert_true(last_prio == spawn_prio, NULL); k_sleep(100); k_thread_abort(tid); spawn_prio = last_prio + 1; tid = k_thread_create(&tdata, tstack, STACK_SIZE, thread_entry, NULL, NULL, NULL, spawn_prio, 0, 0); /* checkpoint: thread is not preempted by lower thread */ zassert_false(last_prio == spawn_prio, NULL); k_thread_abort(tid); /* restore environment */ k_thread_priority_set(k_current_get(), old_prio); }
void main(void) { int status = TC_FAIL; u32_t start_tick; u32_t end_tick; TC_START("Test kernel Sleep and Wakeup APIs\n"); test_objects_init(); test_thread_id = k_thread_create(&test_thread_data, test_thread_stack, THREAD_STACK, (k_thread_entry_t) test_thread, 0, 0, NULL, TEST_THREAD_PRIORITY, 0, 0); TC_PRINT("Test thread started: id = %p\n", test_thread_id); helper_thread_id = k_thread_create(&helper_thread_data, helper_thread_stack, THREAD_STACK, (k_thread_entry_t) helper_thread, 0, 0, NULL, HELPER_THREAD_PRIORITY, 0, 0); TC_PRINT("Helper thread started: id = %p\n", helper_thread_id); /* Activate test_thread */ k_sem_give(&test_thread_sem); /* Wait for test_thread to activate us */ k_sem_take(&task_sem, K_FOREVER); /* Wake the test fiber */ k_wakeup(test_thread_id); if (test_failure) { goto done_tests; } TC_PRINT("Testing kernel k_sleep()\n"); align_to_tick_boundary(); start_tick = k_uptime_get_32(); /* FIXME: one tick less to account for * one extra tick for _TICK_ALIGN in k_sleep*/ k_sleep(ONE_SECOND - TICKS_PER_MS); end_tick = k_uptime_get_32(); if (!sleep_time_valid(start_tick, end_tick, ONE_SECOND)) { TC_ERROR("k_sleep() slept for %d ticks, not %d\n", end_tick - start_tick, ONE_SECOND); goto done_tests; } status = TC_PASS; done_tests: TC_END_REPORT(status); }
static int h4_open(void) { BT_DBG(""); uart_irq_rx_disable(h4_dev); uart_irq_tx_disable(h4_dev); #if defined(CONFIG_BT_NRF51_PM) if (nrf51_init(h4_dev) < 0) { return -EIO; } #else h4_discard(h4_dev, 32); #endif uart_irq_callback_set(h4_dev, bt_uart_isr); k_thread_create(&rx_thread_data, rx_thread_stack, K_THREAD_STACK_SIZEOF(rx_thread_stack), rx_thread, NULL, NULL, NULL, K_PRIO_COOP(CONFIG_BT_RX_PRIO), 0, K_NO_WAIT); return 0; }
void main(void) { int err; init_app(); err = bt_enable(NULL); if (err) { printk("Bluetooth init failed (err %d)\n", err); return; } printk("Bluetooth initialized\n"); ipss_init(); err = ipss_advertise(); if (err) { printk("Advertising failed to start (err %d)\n", err); return; } printk("Advertising successfully started\n"); k_thread_create(&thread_data, thread_stack, STACKSIZE, (k_thread_entry_t)listen, NULL, NULL, NULL, K_PRIO_COOP(7), 0, 0); }
static int nrf5_init(struct device *dev) { const struct nrf5_802154_config *nrf5_radio_cfg = NRF5_802154_CFG(dev); struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev); struct device *clk_m16; k_sem_init(&nrf5_radio->rx_wait, 0, 1); k_sem_init(&nrf5_radio->tx_wait, 0, 1); k_sem_init(&nrf5_radio->cca_wait, 0, 1); clk_m16 = device_get_binding(CONFIG_CLOCK_CONTROL_NRF5_M16SRC_DRV_NAME); if (!clk_m16) { return -ENODEV; } clock_control_on(clk_m16, NULL); nrf_drv_radio802154_init(); nrf5_radio_cfg->irq_config_func(dev); k_thread_create(&nrf5_radio->rx_thread, nrf5_radio->rx_stack, CONFIG_IEEE802154_NRF5_RX_STACK_SIZE, nrf5_rx_thread, dev, NULL, NULL, K_PRIO_COOP(2), 0, 0); SYS_LOG_INF("nRF5 802154 radio initialized"); return 0; }
static void threads_suspend_resume(int prio) { int old_prio = k_thread_priority_get(k_current_get()); /* set current thread */ last_prio = prio; k_thread_priority_set(k_current_get(), last_prio); /* create thread with lower priority */ int create_prio = last_prio + 1; k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, thread_entry, NULL, NULL, NULL, create_prio, 0, 0); /* checkpoint: suspend current thread */ k_thread_suspend(tid); k_sleep(100); /* checkpoint: created thread shouldn't be executed after suspend */ zassert_false(last_prio == create_prio, NULL); k_thread_resume(tid); k_sleep(100); /* checkpoint: created thread should be executed after resume */ zassert_true(last_prio == create_prio, NULL); k_thread_abort(tid); /* restore environment */ k_thread_priority_set(k_current_get(), old_prio); }
static int start_https(struct http_client_ctx *ctx) { struct k_sem startup_sync; /* Start the thread that handles HTTPS traffic. */ if (ctx->https.tid) { return -EALREADY; } NET_DBG("Starting HTTPS thread for %p", ctx); k_sem_init(&startup_sync, 0, 1); ctx->https.tid = k_thread_create(&ctx->https.thread, ctx->https.stack, ctx->https.stack_size, (k_thread_entry_t)https_handler, ctx, &startup_sync, 0, K_PRIO_COOP(7), 0, 0); /* Wait until we know that the HTTPS thread startup was ok */ if (k_sem_take(&startup_sync, HTTPS_STARTUP_TIMEOUT) < 0) { https_shutdown(ctx); return -ECANCELED; } NET_DBG("HTTPS thread %p started for %p", ctx->https.tid, ctx); return 0; }
int bmg160_trigger_init(struct device *dev) { const struct bmg160_device_config *cfg = dev->config->config_info; struct bmg160_device_data *bmg160 = dev->driver_data; /* set INT1 pin to: push-pull, active low */ if (bmg160_write_byte(dev, BMG160_REG_INT_EN1, 0) < 0) { SYS_LOG_DBG("Failed to select interrupt pins type."); return -EIO; } /* set interrupt mode to non-latched */ if (bmg160_write_byte(dev, BMG160_REG_INT_RST_LATCH, 0) < 0) { SYS_LOG_DBG("Failed to set the interrupt mode."); return -EIO; } /* map anymotion and high rate interrupts to INT1 pin */ if (bmg160_write_byte(dev, BMG160_REG_INT_MAP0, BMG160_INT1_ANY | BMG160_INT1_HIGH) < 0) { SYS_LOG_DBG("Unable to map interrupts."); return -EIO; } /* map data ready, FIFO and FastOffset interrupts to INT1 pin */ if (bmg160_write_byte(dev, BMG160_REG_INT_MAP1, BMG160_INT1_DATA | BMG160_INT1_FIFO | BMG160_INT1_FAST_OFFSET) < 0) { SYS_LOG_DBG("Unable to map interrupts."); return -EIO; } bmg160->gpio = device_get_binding((char *)cfg->gpio_port); if (!bmg160->gpio) { SYS_LOG_DBG("Gpio controller %s not found", cfg->gpio_port); return -EINVAL; } #if defined(CONFIG_BMG160_TRIGGER_OWN_THREAD) k_sem_init(&bmg160->trig_sem, 0, UINT_MAX); k_thread_create(&bmg160_thread, bmg160_thread_stack, CONFIG_BMG160_THREAD_STACK_SIZE, bmg160_thread_main, dev, NULL, NULL, K_PRIO_COOP(10), 0, 0); #elif defined(CONFIG_BMG160_TRIGGER_GLOBAL_THREAD) bmg160->work.handler = bmg160_work_cb; bmg160->dev = dev; #endif gpio_pin_configure(bmg160->gpio, cfg->int_pin, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE); gpio_init_callback(&bmg160->gpio_cb, bmg160_gpio_callback, BIT(cfg->int_pin)); gpio_add_callback(bmg160->gpio, &bmg160->gpio_cb); gpio_pin_enable_callback(bmg160->gpio, cfg->int_pin); return 0; }
/* * SimpleLink does not have an init hook, so we export this function to * be called early during system initialization. */ static int dpl_zephyr_init(struct device *port) { (void)k_thread_create(&spawn_task_data, spawn_task_stack, SPAWN_TASK_STACKSIZE, spawn_task, NULL, NULL, NULL, SPAWN_TASK_PRIORITY, 0, K_NO_WAIT); return 0; }
static void create_rx_handler(struct eth_context *ctx) { k_thread_create(&rx_thread_data, eth_rx_stack, K_THREAD_STACK_SIZEOF(eth_rx_stack), (k_thread_entry_t)eth_rx, ctx, NULL, NULL, K_PRIO_COOP(14), 0, K_NO_WAIT); }
static void init_rx_queue(void) { k_fifo_init(&rx_queue); k_thread_create(&rx_thread_data, rx_stack, K_THREAD_STACK_SIZEOF(rx_stack), (k_thread_entry_t)rx_thread, NULL, NULL, NULL, K_PRIO_COOP(8), 0, K_NO_WAIT); }
static int lwm2m_rd_client_init(struct device *dev) { k_thread_create(&lwm2m_rd_client_thread_data, &lwm2m_rd_client_thread_stack[0], K_THREAD_STACK_SIZEOF(lwm2m_rd_client_thread_stack), (k_thread_entry_t) lwm2m_rd_client_service, NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT); SYS_LOG_DBG("LWM2M RD client thread started"); return 0; }
static void init_tx_queue(void) { k_sem_init(&tx_sem, 0, UINT_MAX); k_fifo_init(&tx_queue); k_thread_create(&tx_thread_data, tx_stack, K_THREAD_STACK_SIZEOF(tx_stack), (k_thread_entry_t)tx_thread, NULL, NULL, NULL, K_PRIO_COOP(8), 0, K_NO_WAIT); }
static void tsema_thread_thread(struct k_sem *psem) { /**TESTPOINT: thread-thread sync via sema*/ k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, tThread_entry, psem, NULL, NULL, K_PRIO_PREEMPT(0), 0, 0); zassert_false(k_sem_take(psem, K_FOREVER), NULL); /*clean the spawn thread avoid side effect in next TC*/ k_thread_abort(tid); }
void test_threads_abort_self(void) { execute_flag = 0; k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, thread_entry_abort, NULL, NULL, NULL, 0, 0, 0); k_sleep(100); /**TESTPOINT: spawned thread executed but abort itself*/ zassert_true(execute_flag == 1, NULL); k_thread_abort(tid); }
void main(void) { if (init_app() != 0) { printk("Cannot initialize network\n"); return; } k_thread_create(&thread_data, stack, STACK_SIZE, (k_thread_entry_t) dtls_server, NULL, NULL, NULL, K_PRIO_COOP(7), 0, 0); }
int lsm6dsl_init_interrupt(struct device *dev) { struct lsm6dsl_data *drv_data = dev->driver_data; /* setup data ready gpio interrupt */ drv_data->gpio = device_get_binding(CONFIG_LSM6DSL_GPIO_DEV_NAME); if (drv_data->gpio == NULL) { SYS_LOG_ERR("Cannot get pointer to %s device.", CONFIG_LSM6DSL_GPIO_DEV_NAME); return -EINVAL; } gpio_pin_configure(drv_data->gpio, CONFIG_LSM6DSL_GPIO_PIN_NUM, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&drv_data->gpio_cb, lsm6dsl_gpio_callback, BIT(CONFIG_LSM6DSL_GPIO_PIN_NUM)); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) { SYS_LOG_ERR("Could not set gpio callback."); return -EIO; } /* enable data-ready interrupt */ if (drv_data->hw_tf->update_reg(drv_data, LSM6DSL_REG_INT1_CTRL, LSM6DSL_SHIFT_INT1_CTRL_DRDY_XL | LSM6DSL_SHIFT_INT1_CTRL_DRDY_G, (1 << LSM6DSL_SHIFT_INT1_CTRL_DRDY_XL) | (1 << LSM6DSL_SHIFT_INT1_CTRL_DRDY_G)) < 0) { SYS_LOG_ERR("Could not enable data-ready interrupt."); return -EIO; } #if defined(CONFIG_LSM6DSL_TRIGGER_OWN_THREAD) k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX); k_thread_create(&drv_data->thread, drv_data->thread_stack, CONFIG_LSM6DSL_THREAD_STACK_SIZE, (k_thread_entry_t)lsm6dsl_thread, dev, 0, NULL, K_PRIO_COOP(CONFIG_LSM6DSL_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_LSM6DSL_TRIGGER_GLOBAL_THREAD) drv_data->work.handler = lsm6dsl_work_cb; drv_data->dev = dev; #endif gpio_pin_enable_callback(drv_data->gpio, CONFIG_LSM6DSL_GPIO_PIN_NUM); return 0; }
void test_pipe_get_put(void) { /**TESTPOINT: test API sequence: [get, put]*/ k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, tThread_block_put, &kpipe, NULL, NULL, K_PRIO_PREEMPT(0), 0, 0); /*get will be executed previor to put*/ tpipe_get(&kpipe); k_sem_take(&end_sema, K_FOREVER); k_thread_abort(tid); }
int lis2dw12_init_interrupt(struct device *dev) { struct lis2dw12_data *lis2dw12 = dev->driver_data; const struct lis2dw12_device_config *cfg = dev->config->config_info; int ret; /* setup data ready gpio interrupt (INT1 or INT2) */ lis2dw12->gpio = device_get_binding(cfg->int_gpio_port); if (lis2dw12->gpio == NULL) { LOG_DBG("Cannot get pointer to %s device", cfg->int_gpio_port); return -EINVAL; } #if defined(CONFIG_LIS2DW12_TRIGGER_OWN_THREAD) k_sem_init(&lis2dw12->gpio_sem, 0, UINT_MAX); k_thread_create(&lis2dw12->thread, lis2dw12->thread_stack, CONFIG_LIS2DW12_THREAD_STACK_SIZE, (k_thread_entry_t)lis2dw12_thread, dev, 0, NULL, K_PRIO_COOP(CONFIG_LIS2DW12_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD) lis2dw12->work.handler = lis2dw12_work_cb; lis2dw12->dev = dev; #endif /* CONFIG_LIS2DW12_TRIGGER_OWN_THREAD */ ret = gpio_pin_configure(lis2dw12->gpio, cfg->int_gpio_pin, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); if (ret < 0) { LOG_DBG("Could not configure gpio"); return ret; } gpio_init_callback(&lis2dw12->gpio_cb, lis2dw12_gpio_callback, BIT(cfg->int_gpio_pin)); if (gpio_add_callback(lis2dw12->gpio, &lis2dw12->gpio_cb) < 0) { LOG_DBG("Could not set gpio callback"); return -EIO; } /* enable interrupt on int1/int2 in pulse mode */ if (lis2dw12->hw_tf->update_reg(lis2dw12, LIS2DW12_CTRL3_ADDR, LIS2DW12_LIR_MASK, LIS2DW12_DIS_BIT)) { return -EIO; } return gpio_pin_enable_callback(lis2dw12->gpio, cfg->int_gpio_pin); }
void test_pipe_block_put(void) { /**TESTPOINT: test k_pipe_block_put without semaphore*/ k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, tThread_block_put, &kpipe, NULL, NULL, K_PRIO_PREEMPT(0), 0, 0); k_sleep(10); tpipe_get(&kpipe); k_sem_take(&end_sema, K_FOREVER); k_thread_abort(tid); }
void test_threads_abort_others(void) { execute_flag = 0; k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, thread_entry, NULL, NULL, NULL, 0, 0, 0); k_thread_abort(tid); k_sleep(100); /**TESTPOINT: check not-started thread is aborted*/ zassert_true(execute_flag == 0, NULL); tid = k_thread_create(&tdata, tstack, STACK_SIZE, thread_entry, NULL, NULL, NULL, 0, 0, 0); k_sleep(50); k_thread_abort(tid); /**TESTPOINT: check running thread is aborted*/ zassert_true(execute_flag == 1, NULL); k_sleep(1000); zassert_true(execute_flag == 1, NULL); }
int mpu6050_init_interrupt(struct device *dev) { struct mpu6050_data *drv_data = dev->driver_data; /* setup data ready gpio interrupt */ drv_data->gpio = device_get_binding(CONFIG_MPU6050_GPIO_DEV_NAME); if (drv_data->gpio == NULL) { SYS_LOG_ERR("Failed to get pointer to %s device", CONFIG_MPU6050_GPIO_DEV_NAME); return -EINVAL; } gpio_pin_configure(drv_data->gpio, CONFIG_MPU6050_GPIO_PIN_NUM, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&drv_data->gpio_cb, mpu6050_gpio_callback, BIT(CONFIG_MPU6050_GPIO_PIN_NUM)); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) { SYS_LOG_ERR("Failed to set gpio callback"); return -EIO; } /* enable data ready interrupt */ if (i2c_reg_write_byte(drv_data->i2c, CONFIG_MPU6050_I2C_ADDR, MPU6050_REG_INT_EN, MPU6050_DRDY_EN) < 0) { SYS_LOG_ERR("Failed to enable data ready interrupt."); return -EIO; } #if defined(CONFIG_MPU6050_TRIGGER_OWN_THREAD) k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX); k_thread_create(&drv_data->thread, drv_data->thread_stack, CONFIG_MPU6050_THREAD_STACK_SIZE, (k_thread_entry_t)mpu6050_thread, dev, 0, NULL, K_PRIO_COOP(CONFIG_MPU6050_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD) drv_data->work.handler = mpu6050_work_cb; drv_data->dev = dev; #endif gpio_pin_enable_callback(drv_data->gpio, CONFIG_MPU6050_GPIO_PIN_NUM); return 0; }
void test_pipe_block_put_sema(void) { struct k_sem sync_sema; k_sem_init(&sync_sema, 0, 1); /**TESTPOINT: test k_pipe_block_put with semaphore*/ k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, tThread_block_put, &pipe, &sync_sema, NULL, K_PRIO_PREEMPT(0), 0, 0); k_sleep(10); tpipe_get(&pipe); k_sem_take(&end_sema, K_FOREVER); k_thread_abort(tid); }
static void tmutex_test_lock(struct k_mutex *pmutex, void (*entry_fn)(void *, void *, void *)) { k_mutex_init(pmutex); k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, entry_fn, pmutex, NULL, NULL, K_PRIO_PREEMPT(0), 0, 0); k_mutex_lock(pmutex, K_FOREVER); TC_PRINT("access resource from main thread\n"); /* wait for spawn thread to take action */ k_sleep(TIMEOUT); /* teardown */ k_thread_abort(tid); }
int eswifi_spi_init(struct eswifi_dev *eswifi) { struct eswifi_spi_data *spi = &eswifi_spi0; /* Static instance */ /* SPI DEV */ spi->spi_dev = device_get_binding(DT_INVENTEK_ESWIFI_ESWIFI0_BUS_NAME); if (!spi->spi_dev) { LOG_ERR("Failed to initialize SPI driver"); return -ENODEV; } /* SPI DATA READY PIN */ spi->dr.dev = device_get_binding( DT_INVENTEK_ESWIFI_ESWIFI0_DATA_GPIOS_CONTROLLER); if (!spi->dr.dev) { LOG_ERR("Failed to initialize GPIO driver: %s", DT_INVENTEK_ESWIFI_ESWIFI0_DATA_GPIOS_CONTROLLER); return -ENODEV; } spi->dr.pin = DT_INVENTEK_ESWIFI_ESWIFI0_DATA_GPIOS_PIN; gpio_pin_configure(spi->dr.dev, spi->dr.pin, GPIO_DIR_IN); /* SPI CONFIG/CS */ spi->spi_cfg.frequency = DT_INVENTEK_ESWIFI_ESWIFI0_SPI_MAX_FREQUENCY; spi->spi_cfg.operation = (SPI_OP_MODE_MASTER | SPI_TRANSFER_MSB | SPI_WORD_SET(16) | SPI_LINES_SINGLE | SPI_HOLD_ON_CS | SPI_LOCK_ON); spi->spi_cfg.slave = DT_INVENTEK_ESWIFI_ESWIFI0_BASE_ADDRESS; spi->spi_cs.gpio_dev = device_get_binding(DT_INVENTEK_ESWIFI_ESWIFI0_CS_GPIO_CONTROLLER); spi->spi_cs.gpio_pin = DT_INVENTEK_ESWIFI_ESWIFI0_CS_GPIO_PIN; spi->spi_cs.delay = 1000; spi->spi_cfg.cs = &spi->spi_cs; eswifi->bus_data = spi; LOG_DBG("success"); k_thread_create(&spi->poll_thread, eswifi_spi_poll_stack, ESWIFI_SPI_THREAD_STACK_SIZE, (k_thread_entry_t)eswifi_spi_poll_thread, eswifi, NULL, NULL, K_PRIO_COOP(CONFIG_WIFI_ESWIFI_THREAD_PRIO), 0, K_NO_WAIT); return 0; }
static void tpipe_thread_thread(struct k_pipe *ppipe) { k_sem_init(&end_sema, 0, 1); /**TESTPOINT: thread-thread data passing via pipe*/ k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, tThread_entry, ppipe, NULL, NULL, K_PRIO_PREEMPT(0), 0, 0); tpipe_put(ppipe); k_sem_take(&end_sema, K_FOREVER); k_sem_take(&end_sema, K_FOREVER); tpipe_get(ppipe); /* clear the spawned thread avoid side effect */ k_thread_abort(tid); }
void tester_init(void) { int i; for (i = 0; i < CMD_QUEUED; i++) { k_fifo_put(&avail_queue, &cmd_buf[i * BTP_MTU]); } k_thread_create(&cmd_thread, stack, STACKSIZE, cmd_handler, NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT); uart_pipe_register(k_fifo_get(&avail_queue, K_NO_WAIT), BTP_MTU, recv_cb); tester_send(BTP_SERVICE_ID_CORE, CORE_EV_IUT_READY, BTP_INDEX_NONE, NULL, 0); }
/*test cases*/ void test_threads_cancel_undelayed(void) { int cur_prio = k_thread_priority_get(k_current_get()); /* spawn thread with lower priority */ int spawn_prio = cur_prio + 1; k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE, thread_entry, NULL, NULL, NULL, spawn_prio, 0, 0); /**TESTPOINT: check cancel retcode when thread is not delayed*/ int cancel_ret = k_thread_cancel(tid); zassert_equal(cancel_ret, -EINVAL, NULL); k_thread_abort(tid); }
int bmi160_trigger_mode_init(struct device *dev) { struct bmi160_device_data *bmi160 = dev->driver_data; const struct bmi160_device_config *cfg = dev->config->config_info; bmi160->gpio = device_get_binding((char *)cfg->gpio_port); if (!bmi160->gpio) { LOG_DBG("Gpio controller %s not found.", cfg->gpio_port); return -EINVAL; } #if defined(CONFIG_BMI160_TRIGGER_OWN_THREAD) k_sem_init(&bmi160->sem, 0, UINT_MAX); k_thread_create(&bmi160_thread, bmi160_thread_stack, CONFIG_BMI160_THREAD_STACK_SIZE, bmi160_thread_main, dev, NULL, NULL, K_PRIO_COOP(CONFIG_BMI160_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_BMI160_TRIGGER_GLOBAL_THREAD) bmi160->work.handler = bmi160_work_handler; bmi160->dev = dev; #endif /* map all interrupts to INT1 pin */ if (bmi160_word_write(dev, BMI160_REG_INT_MAP0, 0xf0ff) < 0) { LOG_DBG("Failed to map interrupts."); return -EIO; } gpio_pin_configure(bmi160->gpio, cfg->int_pin, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE); gpio_init_callback(&bmi160->gpio_cb, bmi160_gpio_callback, BIT(cfg->int_pin)); gpio_add_callback(bmi160->gpio, &bmi160->gpio_cb); gpio_pin_enable_callback(bmi160->gpio, cfg->int_pin); return bmi160_byte_write(dev, BMI160_REG_INT_OUT_CTRL, BMI160_INT1_OUT_EN | BMI160_INT1_EDGE_CTRL); }