int lis2ds12_trigger_set(struct device *dev, const struct sensor_trigger *trig, sensor_trigger_handler_t handler) { struct lis2ds12_data *data = dev->driver_data; u8_t buf[6]; __ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY); gpio_pin_disable_callback(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN); data->data_ready_handler = handler; if (handler == NULL) { LOG_WRN("lis2ds12: no handler"); return 0; } /* re-trigger lost interrupt */ if (data->hw_tf->read_data(data, LIS2DS12_REG_OUTX_L, buf, sizeof(buf)) < 0) { LOG_ERR("status reading error"); return -EIO; } data->data_ready_trigger = *trig; lis2ds12_init_interrupt(dev); gpio_pin_enable_callback(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN); return 0; }
void detachInterrupt(uint32_t pin) { struct device *gpiob; gpiob = device_get_binding(PORT); gpio_pin_disable_callback(gpiob, zephyrDescription[pin].zephyrPin1); }
static void init_callback(struct device *dev) { gpio_pin_disable_callback(dev, PIN_IN); gpio_pin_disable_callback(dev, PIN_OUT); /* 1. set PIN_OUT */ gpio_pin_configure(dev, PIN_OUT, GPIO_DIR_OUT); gpio_pin_write(dev, PIN_OUT, 0); /* 2. configure PIN_IN callback and trigger condition */ gpio_pin_configure(dev, PIN_IN, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | \ GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&cb_data[0].gpio_cb, callback_1, BIT(PIN_IN)); gpio_add_callback(dev, &cb_data[0].gpio_cb); gpio_init_callback(&cb_data[1].gpio_cb, callback_2, BIT(PIN_IN)); gpio_add_callback(dev, &cb_data[1].gpio_cb); }
static void tmp007_gpio_callback(struct device *dev, struct gpio_callback *cb, uint32_t pins) { struct tmp007_data *drv_data = CONTAINER_OF(cb, struct tmp007_data, gpio_cb); gpio_pin_disable_callback(dev, CONFIG_TMP007_GPIO_PIN_NUM); #if defined(CONFIG_TMP007_TRIGGER_OWN_FIBER) nano_sem_give(&drv_data->gpio_sem); #elif defined(CONFIG_TMP007_TRIGGER_GLOBAL_FIBER) nano_isr_fifo_put(sensor_get_work_fifo(), &drv_data->work); #endif }
static void apds9960_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) { struct apds9960_data *drv_data = CONTAINER_OF(cb, struct apds9960_data, gpio_cb); gpio_pin_disable_callback(dev, DT_AVAGO_APDS9960_0_INT_GPIOS_PIN); #ifdef CONFIG_APDS9960_TRIGGER k_work_submit(&drv_data->work); #else k_sem_give(&drv_data->data_sem); #endif }
static void adxl372_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) { struct adxl372_data *drv_data = CONTAINER_OF(cb, struct adxl372_data, gpio_cb); const struct adxl372_dev_config *cfg = dev->config->config_info; gpio_pin_disable_callback(dev, cfg->int_gpio); #if defined(CONFIG_ADXL372_TRIGGER_OWN_THREAD) k_sem_give(&drv_data->gpio_sem); #elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD) k_work_submit(&drv_data->work); #endif }
static void trigger_callback(struct device *dev, int enable_cb) { gpio_pin_write(dev, PIN_OUT, 0); k_sleep(100); cb_cnt[0] = 0; cb_cnt[1] = 0; if (enable_cb == 1) { gpio_pin_enable_callback(dev, PIN_IN); } else { gpio_pin_disable_callback(dev, PIN_IN); } k_sleep(100); gpio_pin_write(dev, PIN_OUT, 1); k_sleep(1000); }
static void mpu6050_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) { struct mpu6050_data *drv_data = CONTAINER_OF(cb, struct mpu6050_data, gpio_cb); ARG_UNUSED(pins); gpio_pin_disable_callback(dev, CONFIG_MPU6050_GPIO_PIN_NUM); #if defined(CONFIG_MPU6050_TRIGGER_OWN_THREAD) k_sem_give(&drv_data->gpio_sem); #elif defined(CONFIG_MPU6050_TRIGGER_GLOBAL_THREAD) k_work_submit(&drv_data->work); #endif }
static void lis2ds12_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) { struct lis2ds12_data *data = CONTAINER_OF(cb, struct lis2ds12_data, gpio_cb); ARG_UNUSED(pins); gpio_pin_disable_callback(dev, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN); #if defined(CONFIG_LIS2DS12_TRIGGER_OWN_THREAD) k_sem_give(&data->trig_sem); #elif defined(CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD) k_work_submit(&data->work); #endif }
static void lis2dw12_gpio_callback(struct device *dev, struct gpio_callback *cb, u32_t pins) { struct lis2dw12_data *lis2dw12 = CONTAINER_OF(cb, struct lis2dw12_data, gpio_cb); const struct lis2dw12_device_config *cfg = dev->config->config_info; ARG_UNUSED(pins); gpio_pin_disable_callback(dev, cfg->int_gpio_pin); #if defined(CONFIG_LIS2DW12_TRIGGER_OWN_THREAD) k_sem_give(&lis2dw12->gpio_sem); #elif defined(CONFIG_LIS2DW12_TRIGGER_GLOBAL_THREAD) k_work_submit(&lis2dw12->work); #endif /* CONFIG_LIS2DW12_TRIGGER_OWN_THREAD */ }
int adxl372_trigger_set(struct device *dev, const struct sensor_trigger *trig, sensor_trigger_handler_t handler) { struct adxl372_data *drv_data = dev->driver_data; const struct adxl372_dev_config *cfg = dev->config->config_info; u8_t int_mask, int_en, status1, status2; int ret; gpio_pin_disable_callback(drv_data->gpio, cfg->int_gpio); switch (trig->type) { case SENSOR_TRIG_THRESHOLD: drv_data->th_handler = handler; drv_data->th_trigger = *trig; int_mask = ADXL372_INT1_MAP_ACT_MSK | ADXL372_INT1_MAP_INACT_MSK; break; case SENSOR_TRIG_DATA_READY: drv_data->drdy_handler = handler; drv_data->drdy_trigger = *trig; int_mask = ADXL372_INT1_MAP_DATA_RDY_MSK; break; default: SYS_LOG_ERR("Unsupported sensor trigger"); ret = -ENOTSUP; goto out; } if (handler) { int_en = int_mask; } else { int_en = 0; }; ret = adxl372_reg_write_mask(dev, ADXL372_INT1_MAP, int_mask, int_en); adxl372_get_status(dev, &status1, &status2, NULL); /* Clear status */ out: gpio_pin_enable_callback(drv_data->gpio, cfg->int_gpio); return ret; }
int tmp007_trigger_set(struct device *dev, const struct sensor_trigger *trig, sensor_trigger_handler_t handler) { struct tmp007_data *drv_data = dev->driver_data; gpio_pin_disable_callback(drv_data->gpio, CONFIG_TMP007_GPIO_PIN_NUM); if (trig->type == SENSOR_TRIG_DATA_READY) { drv_data->drdy_handler = handler; drv_data->drdy_trigger = *trig; } else if (trig->type == SENSOR_TRIG_THRESHOLD) { drv_data->th_handler = handler; drv_data->th_trigger = *trig; } gpio_pin_enable_callback(drv_data->gpio, CONFIG_TMP007_GPIO_PIN_NUM); return 0; }
int hts221_trigger_set(struct device *dev, const struct sensor_trigger *trig, sensor_trigger_handler_t handler) { struct hts221_data *drv_data = dev->driver_data; __ASSERT_NO_MSG(trig->type == SENSOR_TRIG_DATA_READY); gpio_pin_disable_callback(drv_data->gpio, CONFIG_HTS221_GPIO_PIN_NUM); drv_data->data_ready_handler = handler; if (handler == NULL) { return 0; } drv_data->data_ready_trigger = *trig; gpio_pin_enable_callback(drv_data->gpio, CONFIG_HTS221_GPIO_PIN_NUM); return 0; }
int mpu6050_trigger_set(struct device *dev, const struct sensor_trigger *trig, sensor_trigger_handler_t handler) { struct mpu6050_data *drv_data = dev->driver_data; if (trig->type != SENSOR_TRIG_DATA_READY) { return -ENOTSUP; } gpio_pin_disable_callback(drv_data->gpio, CONFIG_MPU6050_GPIO_PIN_NUM); drv_data->data_ready_handler = handler; if (handler == NULL) { return 0; } drv_data->data_ready_trigger = *trig; gpio_pin_enable_callback(drv_data->gpio, CONFIG_MPU6050_GPIO_PIN_NUM); return 0; }
static void bt_spi_rx_thread(void) { struct net_buf *buf; u8_t header_master[5] = { SPI_READ, 0x00, 0x00, 0x00, 0x00 }; u8_t header_slave[5]; struct bt_hci_acl_hdr acl_hdr; u8_t size; memset(&txmsg, 0xFF, SPI_MAX_MSG_LEN); while (true) { k_sem_take(&sem_request, K_FOREVER); /* Disable IRQ pin callback to avoid spurious IRQs */ gpio_pin_disable_callback(irq_dev, GPIO_IRQ_PIN); k_sem_take(&sem_busy, K_FOREVER); do { #if defined(CONFIG_BLUETOOTH_SPI_BLUENRG) gpio_pin_write(cs_dev, GPIO_CS_PIN, 1); gpio_pin_write(cs_dev, GPIO_CS_PIN, 0); #endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */ spi_transceive(spi_dev, header_master, 5, header_slave, 5); } while (header_slave[STATUS_HEADER_TOREAD] == 0 || header_slave[STATUS_HEADER_TOREAD] == 0xFF); size = header_slave[STATUS_HEADER_TOREAD]; do { spi_transceive(spi_dev, &txmsg, size, &rxmsg, size); } while (rxmsg[0] == 0); gpio_pin_enable_callback(irq_dev, GPIO_IRQ_PIN); #if defined(CONFIG_BLUETOOTH_SPI_BLUENRG) gpio_pin_write(cs_dev, GPIO_CS_PIN, 1); #endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */ k_sem_give(&sem_busy); spi_dump_message("RX:ed", rxmsg, size); switch (rxmsg[PACKET_TYPE]) { case HCI_EVT: switch (rxmsg[EVT_HEADER_EVENT]) { case BT_HCI_EVT_VENDOR: /* Vendor events are currently unsupported */ bt_spi_handle_vendor_evt(rxmsg); continue; case BT_HCI_EVT_CMD_COMPLETE: case BT_HCI_EVT_CMD_STATUS: buf = bt_buf_get_cmd_complete(K_FOREVER); break; default: buf = bt_buf_get_rx(K_FOREVER); break; } bt_buf_set_type(buf, BT_BUF_EVT); net_buf_add_mem(buf, &rxmsg[1], rxmsg[EVT_HEADER_SIZE] + 2); break; case HCI_ACL: buf = bt_buf_get_rx(K_FOREVER); bt_buf_set_type(buf, BT_BUF_ACL_IN); memcpy(&acl_hdr, &rxmsg[1], sizeof(acl_hdr)); net_buf_add_mem(buf, &acl_hdr, sizeof(acl_hdr)); net_buf_add_mem(buf, &rxmsg[5], sys_le16_to_cpu(acl_hdr.len)); break; default: BT_ERR("Unknown BT buf type %d", rxmsg[0]); continue; } if (rxmsg[PACKET_TYPE] == HCI_EVT && bt_hci_evt_is_prio(rxmsg[EVT_HEADER_EVENT])) { bt_recv_prio(buf); } else { bt_recv(buf); } } }