void attachInterrupt(uint32_t pin, void(*callback)(void), uint32_t mode) { struct device *gpiob; int gpio_mode; switch(mode) { case LOW: gpio_mode = GPIO_DIR_IN | GPIO_INT | GPIO_INT_LEVEL | GPIO_INT_ACTIVE_LOW | PULL_UP; break; case HIGH: gpio_mode = GPIO_DIR_IN | GPIO_INT | GPIO_INT_LEVEL | GPIO_INT_ACTIVE_HIGH | PULL_UP; break; case CHANGE: gpio_mode = GPIO_DIR_IN | GPIO_INT | GPIO_INT_DOUBLE_EDGE | GPIO_INT_ACTIVE_LOW | GPIO_INT_ACTIVE_HIGH | PULL_UP; break; case FALLING: gpio_mode = GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_LOW | PULL_UP; break; case RISING: gpio_mode = GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH | PULL_UP; break; default: gpio_mode = GPIO_DIR_IN | GPIO_INT | GPIO_INT_DOUBLE_EDGE | GPIO_INT_ACTIVE_LOW | GPIO_INT_ACTIVE_HIGH | PULL_UP; } gpiob = device_get_binding(PORT); gpio_pin_configure(gpiob, zephyrDescription[pin].zephyrPin1, gpio_mode); gpio_init_callback(&gpio_cb, callback, BIT(zephyrDescription[pin].zephyrPin1)); gpio_add_callback(gpiob, &gpio_cb); gpio_pin_enable_callback(gpiob, zephyrDescription[pin].zephyrPin1); }
int tmp007_init_interrupt(struct device *dev) { struct tmp007_data *drv_data = dev->driver_data; int rc; rc = tmp007_reg_update(drv_data, TMP007_REG_CONFIG, TMP007_ALERT_EN_BIT, TMP007_ALERT_EN_BIT); if (rc != 0) { SYS_LOG_DBG("Failed to enable interrupt pin!"); return -EIO; } /* setup gpio interrupt */ drv_data->gpio = device_get_binding(CONFIG_TMP007_GPIO_DEV_NAME); if (drv_data->gpio == NULL) { SYS_LOG_DBG("Failed to get pointer to %s device!", CONFIG_TMP007_GPIO_DEV_NAME); return -EINVAL; } gpio_pin_configure(drv_data->gpio, CONFIG_TMP007_GPIO_PIN_NUM, GPIO_DIR_IN | GPIO_INT | GPIO_INT_LEVEL | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&drv_data->gpio_cb, tmp007_gpio_callback, BIT(CONFIG_TMP007_GPIO_PIN_NUM)); rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb); if (rc != 0) { SYS_LOG_DBG("Failed to set gpio callback!"); return -EIO; } #if defined(CONFIG_TMP007_TRIGGER_OWN_FIBER) nano_sem_init(&drv_data->gpio_sem); fiber_start(drv_data->fiber_stack, CONFIG_TMP007_FIBER_STACK_SIZE, (nano_fiber_entry_t)tmp007_fiber, POINTER_TO_INT(dev), 0, CONFIG_TMP007_FIBER_PRIORITY, 0); #elif defined(CONFIG_TMP007_TRIGGER_GLOBAL_FIBER) drv_data->work.handler = tmp007_fiber_cb; drv_data->work.arg = dev; #endif return 0; }
int hts221_init_interrupt(struct device *dev) { struct hts221_data *drv_data = dev->driver_data; /* setup data ready gpio interrupt */ drv_data->gpio = device_get_binding(CONFIG_HTS221_GPIO_DEV_NAME); if (drv_data->gpio == NULL) { SYS_LOG_ERR("Cannot get pointer to %s device.", CONFIG_HTS221_GPIO_DEV_NAME); return -EINVAL; } gpio_pin_configure(drv_data->gpio, CONFIG_HTS221_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, hts221_gpio_callback, BIT(CONFIG_HTS221_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 (i2c_reg_write_byte(drv_data->i2c, HTS221_I2C_ADDR, HTS221_REG_CTRL3, HTS221_DRDY_EN) < 0) { SYS_LOG_ERR("Could not enable data-ready interrupt."); return -EIO; } #if defined(CONFIG_HTS221_TRIGGER_OWN_THREAD) k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX); k_thread_spawn(drv_data->thread_stack, CONFIG_HTS221_THREAD_STACK_SIZE, (k_thread_entry_t)hts221_thread, POINTER_TO_INT(dev), 0, NULL, K_PRIO_COOP(CONFIG_HTS221_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_HTS221_TRIGGER_GLOBAL_THREAD) drv_data->work.handler = hts221_work_cb; drv_data->dev = dev; #endif gpio_pin_enable_callback(drv_data->gpio, CONFIG_HTS221_GPIO_PIN_NUM); return 0; }
static int bt_spi_open(void) { /* Configure RST pin and hold BLE in Reset */ gpio_pin_configure(rst_dev, GPIO_RESET_PIN, GPIO_DIR_OUT | GPIO_PUD_PULL_UP); gpio_pin_write(rst_dev, GPIO_RESET_PIN, 0); spi_configure(spi_dev, &spi_conf); #if defined(CONFIG_BLUETOOTH_SPI_BLUENRG) /* Configure the CS (Chip Select) pin */ gpio_pin_configure(cs_dev, GPIO_CS_PIN, GPIO_DIR_OUT | GPIO_PUD_PULL_UP); gpio_pin_write(cs_dev, GPIO_CS_PIN, 1); #endif /* CONFIG_BLUETOOTH_SPI_BLUENRG */ /* Configure IRQ pin and the IRQ call-back/handler */ gpio_pin_configure(irq_dev, GPIO_IRQ_PIN, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH); gpio_init_callback(&gpio_cb, bt_spi_isr, BIT(GPIO_IRQ_PIN)); if (gpio_add_callback(irq_dev, &gpio_cb)) { return -EINVAL; } if (gpio_pin_enable_callback(irq_dev, GPIO_IRQ_PIN)) { return -EINVAL; } /* Start RX thread */ k_thread_spawn(rx_stack, sizeof(rx_stack), (k_thread_entry_t)bt_spi_rx_thread, NULL, NULL, NULL, K_PRIO_COOP(7), 0, K_NO_WAIT); /* Take BLE out of reset */ gpio_pin_write(rst_dev, GPIO_RESET_PIN, 1); /* Device will let us know when it's ready */ k_sem_take(&sem_initialised, K_FOREVER); return 0; }
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); }
static int apds9960_init_interrupt(struct device *dev) { struct apds9960_data *drv_data = dev->driver_data; /* setup gpio interrupt */ drv_data->gpio = device_get_binding(DT_AVAGO_APDS9960_0_INT_GPIOS_CONTROLLER); if (drv_data->gpio == NULL) { LOG_ERR("Failed to get pointer to %s device!", DT_AVAGO_APDS9960_0_INT_GPIOS_CONTROLLER); return -EINVAL; } gpio_pin_configure(drv_data->gpio, DT_AVAGO_APDS9960_0_INT_GPIOS_PIN, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE | GPIO_PUD_PULL_UP); gpio_init_callback(&drv_data->gpio_cb, apds9960_gpio_callback, BIT(DT_AVAGO_APDS9960_0_INT_GPIOS_PIN)); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) { LOG_DBG("Failed to set gpio callback!"); return -EIO; } #ifdef CONFIG_APDS9960_TRIGGER drv_data->work.handler = apds9960_work_cb; drv_data->dev = dev; if (i2c_reg_update_byte(drv_data->i2c, APDS9960_I2C_ADDRESS, APDS9960_ENABLE_REG, APDS9960_ENABLE_PON, APDS9960_ENABLE_PON)) { LOG_ERR("Power on bit not set."); return -EIO; } #else k_sem_init(&drv_data->data_sem, 0, UINT_MAX); #endif return 0; }
int lis2ds12_trigger_init(struct device *dev) { struct lis2ds12_data *data = dev->driver_data; /* setup data ready gpio interrupt */ data->gpio = device_get_binding(DT_ST_LIS2DS12_0_IRQ_GPIOS_CONTROLLER); if (data->gpio == NULL) { LOG_ERR("Cannot get pointer to %s device.", DT_ST_LIS2DS12_0_IRQ_GPIOS_CONTROLLER); return -EINVAL; } gpio_pin_configure(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&data->gpio_cb, lis2ds12_gpio_callback, BIT(DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN)); if (gpio_add_callback(data->gpio, &data->gpio_cb) < 0) { LOG_ERR("Could not set gpio callback."); return -EIO; } #if defined(CONFIG_LIS2DS12_TRIGGER_OWN_THREAD) k_sem_init(&data->trig_sem, 0, UINT_MAX); k_thread_create(&data->thread, data->thread_stack, CONFIG_LIS2DS12_THREAD_STACK_SIZE, (k_thread_entry_t)lis2ds12_thread, dev, 0, NULL, K_PRIO_COOP(CONFIG_LIS2DS12_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_LIS2DS12_TRIGGER_GLOBAL_THREAD) data->work.handler = lis2ds12_work_cb; data->dev = dev; #endif gpio_pin_enable_callback(data->gpio, DT_ST_LIS2DS12_0_IRQ_GPIOS_PIN); return 0; }
int adxl372_init_interrupt(struct device *dev) { struct adxl372_data *drv_data = dev->driver_data; const struct adxl372_dev_config *cfg = dev->config->config_info; drv_data->gpio = device_get_binding(cfg->gpio_port); if (drv_data->gpio == NULL) { SYS_LOG_ERR("Failed to get pointer to %s device!", cfg->gpio_port); return -EINVAL; } gpio_pin_configure(drv_data->gpio, cfg->int_gpio, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&drv_data->gpio_cb, adxl372_gpio_callback, BIT(cfg->int_gpio)); if (gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb) < 0) { SYS_LOG_ERR("Failed to set gpio callback!"); return -EIO; } #if defined(CONFIG_ADXL372_TRIGGER_OWN_THREAD) k_sem_init(&drv_data->gpio_sem, 0, UINT_MAX); k_thread_create(&drv_data->thread, drv_data->thread_stack, CONFIG_ADXL372_THREAD_STACK_SIZE, (k_thread_entry_t)adxl372_thread, dev, 0, NULL, K_PRIO_COOP(CONFIG_ADXL372_THREAD_PRIORITY), 0, 0); #elif defined(CONFIG_ADXL372_TRIGGER_GLOBAL_THREAD) drv_data->work.handler = adxl372_work_cb; drv_data->dev = dev; #endif return 0; }
int sx9500_setup_interrupt(struct device *dev) { struct sx9500_data *data = dev->driver_data; struct device *gpio; #ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD k_sem_init(&data->sem, 0, UINT_MAX); #else data->work.handler = sx9500_work_cb; data->dev = dev; #endif gpio = device_get_binding(CONFIG_SX9500_GPIO_CONTROLLER); if (!gpio) { SYS_LOG_DBG("sx9500: gpio controller %s not found", CONFIG_SX9500_GPIO_CONTROLLER); return -EINVAL; } gpio_pin_configure(gpio, CONFIG_SX9500_GPIO_PIN, GPIO_DIR_IN | GPIO_INT | GPIO_INT_EDGE | GPIO_INT_ACTIVE_LOW | GPIO_INT_DEBOUNCE); gpio_init_callback(&data->gpio_cb, sx9500_gpio_cb, BIT(CONFIG_SX9500_GPIO_PIN)); gpio_add_callback(gpio, &data->gpio_cb); gpio_pin_enable_callback(gpio, CONFIG_SX9500_GPIO_PIN); #ifdef CONFIG_SX9500_TRIGGER_OWN_THREAD k_thread_spawn(sx9500_thread_stack, CONFIG_SX9500_THREAD_STACK_SIZE, sx9500_thread_main, POINTER_TO_INT(dev), 0, NULL, K_PRIO_COOP(CONFIG_SX9500_THREAD_PRIORITY), 0, 0); #endif return 0; }
void main(void) { struct device *gpiob; gpiob = device_get_binding(PORT); gpio_pin_configure(gpiob, PIN, GPIO_DIR_IN | GPIO_INT | EDGE | PULL_UP); gpio_init_callback(&gpio_cb, button_pressed, BIT(PIN)); gpio_add_callback(gpiob, &gpio_cb); gpio_pin_enable_callback(gpiob, PIN); while (1) { int val = 0; gpio_pin_read(gpiob, PIN, &val); PRINT("GPIO val: %d\n", val); task_sleep(MSEC(500)); } }
static int test_gpio(u32_t pin, u32_t func) { u32_t function; struct gpio_callback gpio_cb; struct device *pinmux = device_get_binding(PINMUX_NAME); if (!pinmux) { TC_PRINT("Cannot get PINMUX\n"); return TC_FAIL; } struct device *gpio_dev = device_get_binding(GPIO_DEV_NAME); if (!gpio_dev) { TC_PRINT("Cannot get GPIO device\n"); return TC_FAIL; } cb_triggered = false; /* 1. Configure PIN_OUT and set init voltage */ if (gpio_pin_configure(gpio_dev, GPIO_OUT, GPIO_DIR_OUT)) { TC_PRINT("PIN_OUT configure fail\n"); return TC_FAIL; } if (gpio_pin_write(gpio_dev, GPIO_OUT, 0)) { TC_PRINT("Set PIN_OUT init LOW fail\n"); return TC_FAIL; } /* 2. Configure PIN_IN and set callback */ if (gpio_pin_configure(gpio_dev, GPIO_IN, GPIO_DIR_IN | GPIO_INT | GPIO_INT_DEBOUNCE | GPIO_INT_LEVEL | GPIO_INT_ACTIVE_HIGH)) { TC_PRINT("PIN_IN configure fail\n"); return TC_FAIL; } gpio_init_callback(&gpio_cb, callback, BIT(GPIO_IN)); if (gpio_add_callback(gpio_dev, &gpio_cb)) { TC_PRINT("Set PIN_IN callback fail\n"); return TC_FAIL; } gpio_pin_enable_callback(gpio_dev, GPIO_IN); /* 3. Verify pinmux_pin_set() */ if (pinmux_pin_set(pinmux, pin, func)) { TC_PRINT("Fail to set pin func, %u : %u\n", pin, func); return TC_FAIL; } /* 4. Verify pinmux_pin_get() */ if (pinmux_pin_get(pinmux, pin, &function)) { TC_PRINT("Fail to get pin func\n"); return TC_FAIL; } /* 5. Verify the setting works */ if (function != func) { TC_PRINT("Error. PINMUX get doesn't match PINMUX set\n"); return TC_FAIL; } /* 6. Set PIN_OUT HIGH and verify pin func works */ if (gpio_pin_write(gpio_dev, GPIO_OUT, 1)) { TC_PRINT("Set PIN_OUT HIGH fail\n"); return TC_FAIL; } k_sleep(1000); if (cb_triggered) { TC_PRINT("GPIO callback is triggered\n"); return TC_PASS; } else { TC_PRINT("GPIO callback is not triggered\n"); return TC_FAIL; } }
int bma280_init_interrupt(struct device *dev) { struct bma280_data *drv_data = dev->driver_data; int rc; /* set latched interrupts */ rc = i2c_reg_write_byte(drv_data->i2c, BMA280_I2C_ADDRESS, BMA280_REG_INT_RST_LATCH, BMA280_BIT_INT_LATCH_RESET | BMA280_INT_MODE_LATCH); if (rc != 0) { SYS_LOG_DBG("Could not set latched interrupts"); return -EIO; } /* setup data ready gpio interrupt */ drv_data->gpio = device_get_binding(CONFIG_BMA280_GPIO_DEV_NAME); if (drv_data->gpio == NULL) { SYS_LOG_DBG("Cannot get pointer to %s device", CONFIG_BMA280_GPIO_DEV_NAME); return -EINVAL; } gpio_pin_configure(drv_data->gpio, CONFIG_BMA280_GPIO_PIN_NUM, GPIO_DIR_IN | GPIO_INT | GPIO_INT_LEVEL | GPIO_INT_ACTIVE_HIGH | GPIO_INT_DEBOUNCE); gpio_init_callback(&drv_data->gpio_cb, bma280_gpio_callback, BIT(CONFIG_BMA280_GPIO_PIN_NUM)); rc = gpio_add_callback(drv_data->gpio, &drv_data->gpio_cb); if (rc != 0) { SYS_LOG_DBG("Could not set gpio callback"); return -EIO; } /* map data ready interrupt to INT1 */ rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, BMA280_REG_INT_MAP_1, BMA280_INT_MAP_1_BIT_DATA, BMA280_INT_MAP_1_BIT_DATA); if (rc != 0) { SYS_LOG_DBG("Could not map data ready interrupt pin"); return -EIO; } /* map any-motion interrupt to INT1 */ rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, BMA280_REG_INT_MAP_0, BMA280_INT_MAP_0_BIT_SLOPE, BMA280_INT_MAP_0_BIT_SLOPE); if (rc != 0) { SYS_LOG_DBG("Could not map any-motion interrupt pin"); return -EIO; } /* disable data ready interrupt */ rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, BMA280_REG_INT_EN_1, BMA280_BIT_DATA_EN, 0); if (rc != 0) { SYS_LOG_DBG("Could not disable data ready interrupt"); return -EIO; } /* disable any-motion interrupt */ rc = i2c_reg_update_byte(drv_data->i2c, BMA280_I2C_ADDRESS, BMA280_REG_INT_EN_0, BMA280_SLOPE_EN_XYZ, 0); if (rc != 0) { SYS_LOG_DBG("Could not disable data ready interrupt"); return -EIO; } #if defined(CONFIG_BMA280_TRIGGER_OWN_FIBER) nano_sem_init(&drv_data->gpio_sem); fiber_start(drv_data->fiber_stack, CONFIG_BMA280_FIBER_STACK_SIZE, (nano_fiber_entry_t)bma280_fiber, POINTER_TO_INT(dev), 0, CONFIG_BMA280_FIBER_PRIORITY, 0); #elif defined(CONFIG_BMA280_TRIGGER_GLOBAL_FIBER) drv_data->work.handler = bma280_fiber_cb; drv_data->work.arg = dev; #endif gpio_pin_enable_callback(drv_data->gpio, CONFIG_BMA280_GPIO_PIN_NUM); return 0; }