Esempio n. 1
0
void at86rf231_gpio_spi_interrupts_init(void)
{
    /* set up GPIO pins */
    /* SCLK and MOSI*/
    GPIOA->CRL &= ~(0xf << (5 * 4));
    GPIOA->CRL |= (0xb << (5 * 4));
    GPIOA->CRL &= ~(0xf << (7 * 4));
    GPIOA->CRL |= (0xb << (7 * 4));
    /* MISO */
    gpio_init_in(SPI_0_MISO_GPIO, GPIO_NOPULL);

    /* SPI init */
    spi_init_master(SPI_0, SPI_CONF_FIRST_RISING, SPI_SPEED_5MHZ);

    spi_poweron(SPI_0);

    /* IRQ0 */
    gpio_init_in(SPI_0_IRQ0_GPIO, GPIO_NOPULL);
    gpio_init_int(SPI_0_IRQ0_GPIO, GPIO_NOPULL, GPIO_RISING, (gpio_cb_t)at86rf231_rx_irq, NULL);

    /* Connect EXTI4 Line to PC4 pin */
    at86rf231_enable_interrupts();

    /* CS */
    gpio_init_out(SPI_0_CS_GPIO, GPIO_NOPULL);
    /* SLEEP */
    gpio_init_out(SPI_0_SLEEP_GPIO, GPIO_NOPULL);
    /* RESET */
    gpio_init_out(SPI_0_RESET_GPIO, GPIO_NOPULL);

}
Esempio n. 2
0
InterruptIn::InterruptIn(PinName pin) : gpio(),
                                        gpio_irq(),
                                        _rise(),
                                        _fall() {
    gpio_irq_init(&gpio_irq, pin, (&InterruptIn::_irq_handler), (uint32_t)this);
    gpio_init_in(&gpio, pin);
}
Esempio n. 3
0
void cc110x_cs(void)
{
    volatile int retry_count = 0;
    /* Switch MISO/GDO1 to GPIO input mode */
    gpio_init_in(CC110X_GDO1, GPIO_NOPULL);
    /* CS to low */
    gpio_clear(CC110X_CS);
    /* Wait for SO to go low (voltage regulator
     * has stabilized and the crystal is running) */
    while (gpio_read(CC110X_GDO1)) {
        /* Wait ~500us and try again */
        hwtimer_wait(CS_SO_WAIT_TIME);

        if (gpio_read(CC110X_GDO1)) {
            retry_count++;

            if (retry_count > CC1100_GDO1_LOW_RETRY) {
                puts("[CC1100 SPI] fatal error\n");
                break;
            }

            gpio_set(CC110X_CS);
            gpio_clear(CC110X_CS);
        }
    }
    /* Switch MISO/GDO1 to SPI mode */
    spi_conf_pins(CC110X_SPI);
}
Esempio n. 4
0
	void DispatcherPrivate::set_receive_input(SYNCHRONIZATION_CHANNEL* channel, PinName pin, PinMode pull, ReceiveChannelMode rcmode)
	{
		if (channel->data->state->recv.mode != ReceiveChannelModeNone)
			gpio_irq_free(&channel->data->state->recv.gpio_irq);

		channel->data->state->recv.mode = rcmode;
		gpio_init_in(&channel->data->state->recv.gpio, pin);
		gpio_irq_init(&channel->data->state->recv.gpio_irq, pin, (&DispatcherPrivate::channel_irq_handler), (uint32_t)channel);
		gpio_mode(&channel->data->state->recv.gpio, pull);
		gpio_irq_event evt = IRQ_NONE;
		switch (rcmode)
		{
		case ReceiveChannelInterruptRise:
			evt = IRQ_RISE;
			break;

		case ReceiveChannelInterruptFall:
			evt = IRQ_FALL;
			break;

		case ReceiveChannelModeNone:
			break;
		}

		if (evt != IRQ_NONE)
		{
			gpio_irq_set(&channel->data->state->recv.gpio_irq, evt, 1);
			gpio_irq_enable(&channel->data->state->recv.gpio_irq);
		}

	}
Esempio n. 5
0
InterruptIn::InterruptIn(PinName pin) : gpio(),
                                        gpio_irq(),
                                        _rise(),
                                        _fall() {
    // No lock needed in the constructor
    gpio_irq_init(&gpio_irq, pin, (&InterruptIn::_irq_handler), (uint32_t)this);
    gpio_init_in(&gpio, pin);
}
Esempio n. 6
0
void pinMode( uint32_t dwPin, uint32_t dwMode )
{
    gpio_t gpio;
    if (dwMode == INPUT)
        gpio_init_in(&gpio, digiPins[dwPin]);
    else
        gpio_init_out(&gpio, digiPins[dwPin]);
}
Esempio n. 7
0
File: gpio.c Progetto: AnonMall/RIOT
int gpio_init_int(gpio_t dev, gpio_pp_t pullup, gpio_flank_t flank, gpio_cb_t cb, void *arg)
{
    int res, pin, irq_num;
    uint32_t mask;
    cc2538_gpio_t* instance;

    /* Note: gpio_init_in() also checks if the gpio is enabled. */
    res = gpio_init_in(dev, pullup);
    if (res < 0) {
        return res;
    }

    /* Store the callback information for later: */
    gpio_config[dev].cb  = cb;
    gpio_config[dev].arg = arg;

    pin = pin_lut[dev];
    mask = GPIO_PIN_MASK(GPIO_BIT_NUM(pin));

    instance = GPIO_NUM_TO_DEV(pin);

    /* Enable power-up interrupts for this GPIO port: */
    SYS_CTRL_IWE |= BIT(GPIO_NUM_TO_PORT_NUM(pin));

    switch(flank) {
        case GPIO_FALLING:
            instance->IBE         &= ~mask;     /**< Not both edges */
            instance->IEV         &= ~mask;     /**< Falling edge */
            instance->P_EDGE_CTRL |=  BIT(pin); /**< Falling edge power-up interrupt */
            break;

        case GPIO_RISING:
            instance->IBE         &= ~mask;     /**< Not both edges */
            instance->IEV         |=  mask;     /**< Rising edge */
            instance->P_EDGE_CTRL &= ~BIT(pin); /**< Rising edge power-up interrupt */
            break;

        case GPIO_BOTH:
            instance->IBE = mask;               /**< Both edges */
            break;
    }

    instance->IS     &= ~mask;                  /**< Edge triggered (as opposed to level-triggered) */
    instance->IC     |=  mask;                  /**< Clear any preexisting interrupt state */
    instance->PI_IEN |= BIT(pin);               /**< Enable power-up interrupts for this pin */

    /* Set interrupt priority for the whole GPIO port: */
    irq_num = GPIO_PORT_A_IRQn + GPIO_NUM_TO_PORT_NUM(pin);
    NVIC_SetPriority(irq_num, GPIO_IRQ_PRIO);

    /* Enable interrupts for the whole GPIO port: */
    NVIC_EnableIRQ(irq_num);

    /* Enable interrupts for the specific pin: */
    instance->IE |= mask;

    return 0;
}
Esempio n. 8
0
int gpio_init_int(gpio_t dev, gpio_pp_t pullup, gpio_flank_t flank, gpio_cb_t cb, void *arg)
{
    int res;
    uint32_t pin;

    res = gpio_init_in(dev, pullup);
    if (res < 0) {
        return res;
    }

    pin = gpio_pin_map[dev];

    /* enable the SYSCFG clock */
    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;

    /* enable IRQ */
    switch (dev) {
#if GPIO_0_EN
        case GPIO_0:
            GPIO_0_EXTI_CFG();
            break;
#endif
#if GPIO_1_EN
        case GPIO_1:
            GPIO_1_EXTI_CFG();
            break;
#endif
#if GPIO_2_EN
        case GPIO_2:
            GPIO_2_EXTI_CFG();
            break;
#endif
#if GPIO_3_EN
        case GPIO_3:
            GPIO_3_EXTI_CFG();
            break;
#endif
#if GPIO_4_EN
        case GPIO_4:
            GPIO_4_EXTI_CFG();
            break;
#endif
#if GPIO_5_EN
        case GPIO_5:
            GPIO_5_EXTI_CFG();
            break;
#endif
#if GPIO_6_EN
        case GPIO_6:
            GPIO_6_EXTI_CFG();
            break;
#endif
#if GPIO_7_EN
        case GPIO_7:
            GPIO_7_EXTI_CFG();
            break;
#endif
#if GPIO_8_EN
        case GPIO_8:
            GPIO_8_EXTI_CFG();
            break;
#endif
#if GPIO_9_EN
        case GPIO_9:
            GPIO_9_EXTI_CFG();
            break;
#endif
#if GPIO_10_EN
        case GPIO_10:
            GPIO_10_EXTI_CFG();
            break;
#endif
#if GPIO_11_EN
        case GPIO_11:
            GPIO_11_EXTI_CFG();
            break;
#endif
#if GPIO_12_EN
        case GPIO_12:
            GPIO_12_EXTI_CFG();
            break;
#endif
#if GPIO_13_EN
        case GPIO_13:
            GPIO_13_EXTI_CFG();
            break;
#endif
#if GPIO_14_EN
        case GPIO_14:
            GPIO_14_EXTI_CFG();
            break;
#endif
#if GPIO_15_EN
        case GPIO_15:
            GPIO_15_EXTI_CFG();
            break;
#endif
    }
    NVIC_SetPriority(gpio_irq_map[dev], GPIO_IRQ_PRIO);
    NVIC_EnableIRQ(gpio_irq_map[dev]);

    /* set callback */
    gpio_config[dev].cb = cb;
    gpio_config[dev].arg = arg;

    /* configure the active edges */
    switch (flank) {
        case GPIO_RISING:
            EXTI->RTSR |= (1 << pin);
            EXTI->FTSR &= ~(1 << pin);
            break;
        case GPIO_FALLING:
            EXTI->RTSR &= ~(1 << pin);
            EXTI->FTSR |= (1 << pin);
            break;
        case GPIO_BOTH:
            EXTI->RTSR |= (1 << pin);
            EXTI->FTSR |= (1 << pin);
            break;
    }

    /* clear any pending requests */
    EXTI->PR = (1 << pin);
    /* enable interrupt for EXTI line */
    EXTI->IMR |= (1 << pin);

    return 0;
}
Esempio n. 9
0
// Change the NMI pin to an input. This allows NMI pin to 
//  be used as a low power mode wakeup.  The application will
//  need to change the pin back to NMI_b or wakeup only occurs once!
void NMI_Handler(void)
{
    gpio_t gpio;
    gpio_init_in(&gpio, PTA4);
}
Esempio n. 10
0
File: gpio.c Progetto: tanupoo/RIOT
int gpio_init_int(gpio_t dev, gpio_pp_t pullup, gpio_flank_t flank, gpio_cb_t cb, void *arg)
{
    int res;
    uint32_t pin = 0;

    /* configure pin as input */
    res = gpio_init_in(dev, pullup);
    if (res < 0) {
        return res;
    }

    /* set interrupt priority (its the same for all EXTI interrupts) */
    NVIC_SetPriority(EXTI0_1_IRQn, GPIO_IRQ_PRIO);
    NVIC_SetPriority(EXTI2_3_IRQn, GPIO_IRQ_PRIO);
    NVIC_SetPriority(EXTI4_15_IRQn, GPIO_IRQ_PRIO);

    /* enable clock of the SYSCFG module for EXTI configuration */
    RCC->APB2ENR |= RCC_APB2ENR_SYSCFGCOMPEN;

    /* read pin number, set EXIT channel and enable global interrupt for EXTI channel */
    switch (dev) {
#ifdef GPIO_0_EN
        case GPIO_0:
            pin = GPIO_0_PIN;
            GPIO_0_EXTI_CFG();
            NVIC_SetPriority(GPIO_0_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_0_IRQ);
            break;
#endif
#ifdef GPIO_1_EN
        case GPIO_1:
            pin = GPIO_1_PIN;
            GPIO_1_EXTI_CFG();
            NVIC_SetPriority(GPIO_1_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_1_IRQ);
            break;
#endif
#ifdef GPIO_2_EN
        case GPIO_2:
            pin = GPIO_2_PIN;
            GPIO_2_EXTI_CFG();
            NVIC_SetPriority(GPIO_2_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_2_IRQ);
            break;
#endif
#ifdef GPIO_3_EN
        case GPIO_3:
            pin = GPIO_3_PIN;
            GPIO_3_EXTI_CFG();
            NVIC_SetPriority(GPIO_3_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_3_IRQ);
            break;
#endif
#ifdef GPIO_4_EN
        case GPIO_4:
            pin = GPIO_4_PIN;
            GPIO_4_EXTI_CFG();
            NVIC_SetPriority(GPIO_4_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_4_IRQ);
            break;
#endif
#ifdef GPIO_5_EN
        case GPIO_5:
            pin = GPIO_5_PIN;
            GPIO_5_EXTI_CFG();
            NVIC_SetPriority(GPIO_5_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_5_IRQ);
            break;
#endif
#ifdef GPIO_6_EN
        case GPIO_6:
            pin = GPIO_6_PIN;
            GPIO_6_EXTI_CFG();
            NVIC_SetPriority(GPIO_6_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_6_IRQ);
            break;
#endif
#ifdef GPIO_7_EN
        case GPIO_7:
            pin = GPIO_7_PIN;
            GPIO_7_EXTI_CFG();
            NVIC_SetPriority(GPIO_7_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_7_IRQ);
            break;
#endif
#ifdef GPIO_8_EN
        case GPIO_8:
            pin = GPIO_8_PIN;
            GPIO_8_EXTI_CFG();
            NVIC_SetPriority(GPIO_8_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_8_IRQ);
            break;
#endif
#ifdef GPIO_9_EN
        case GPIO_9:
            pin = GPIO_9_PIN;
            GPIO_9_EXTI_CFG();
            NVIC_SetPriority(GPIO_9_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_9_IRQ);
            break;
#endif
#ifdef GPIO_10_EN
        case GPIO_10:
            pin = GPIO_10_PIN;
            GPIO_10_EXTI_CFG();
            NVIC_SetPriority(GPIO_10_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_10_IRQ);
            break;
#endif
#ifdef GPIO_11_EN
        case GPIO_11:
            pin = GPIO_11_PIN;
            GPIO_11_EXTI_CFG();
            NVIC_SetPriority(GPIO_11_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_11_IRQ);
            break;
#endif
    }

    /* set callback */
    gpio_config[dev].cb = cb;
    gpio_config[dev].arg = arg;

    /* configure the event that triggers an interrupt */
    switch (flank) {
        case GPIO_RISING:
            EXTI->RTSR |= (1 << pin);
            EXTI->FTSR &= ~(1 << pin);
            break;
        case GPIO_FALLING:
            EXTI->RTSR &= ~(1 << pin);
            EXTI->FTSR |= (1 << pin);
            break;
        case GPIO_BOTH:
            EXTI->RTSR |= (1 << pin);
            EXTI->FTSR |= (1 << pin);
            break;
    }

    /* clear any pending requests */
    EXTI->PR = (1 << pin);
    /* unmask the pins interrupt channel */
    EXTI->IMR |= (1 << pin);

    return 0;
}
Esempio n. 11
0
/**
 * gpio irq init
 *
 * Initialize an external interrupt on a gpio pin
 *
 * @param pin       Pin number to enable gpio.
 * @param handler   Interrupt handler
 * @param arg       Argument to pass to interrupt handler
 * @param trig      Trigger mode of interrupt
 * @param pull      Push/pull mode of input.
 *
 * @return int
 */
int
gpio_irq_init(int pin, gpio_irq_handler_t handler, void *arg,
              gpio_irq_trig_t trig, enum gpio_pull pull)
{
    int rc;
    int irqn;
    int index;
    uint32_t pin_mask;
    EXTI_InitTypeDef exti_cfg;

    /* Configure the gpio for an external interrupt */
    rc = 0;

    pin_mask = GPIO_MASK(pin);
    index = GPIO_INDEX(pin);

    exti_cfg.EXTI_Line = index;
    exti_cfg.EXTI_Mode = EXTI_Mode_Interrupt;
    switch (trig) {
    case GPIO_TRIG_NONE:
        rc = -1;
        break;
    case GPIO_TRIG_RISING:
        exti_cfg.EXTI_Trigger = EXTI_Trigger_Rising;
        break;
    case GPIO_TRIG_FALLING:
        exti_cfg.EXTI_Trigger = EXTI_Trigger_Falling;
        break;
    case GPIO_TRIG_BOTH:
        exti_cfg.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
        break;
    case GPIO_TRIG_LOW:
        rc = -1;
        break;
    case GPIO_TRIG_HIGH:
        rc = -1;
        break;
    default:
        rc = -1;
        break;
    }
    exti_cfg.EXTI_LineCmd = ENABLE;

    /* Check to make sure no error has occurred */
    if (!rc) {
        /* Disable interrupt and clear any pending */
        gpio_irq_disable(pin);
        EXTI_ClearFlag(pin_mask);

        gpio_init_in(pin, pull);

        /* Configure SYSCFG */
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);

        /* Configure EXTI */
        SYSCFG_EXTILineConfig(GPIO_PORT(pin), index);

        EXTI_Init(&exti_cfg);

        /* Set the gpio irq handler */
        gpio_irq_handlers[index].isr = handler;
        gpio_irq_handlers[index].arg = arg;

        /* Configure the GPIO */
        if (!rc) {
            /* Enable interrupt vector in NVIC */
            irqn = hal_gpio_pin_to_irq(pin);
            hal_gpio_set_nvic(irqn);
        }
    }

    return rc;
}
void
sol_interrupt_scheduler_gpio_stop(gpio_t dev, void *handler)
{
    gpio_init_in(dev, GPIO_NOPULL);
    interrupt_scheduler_handler_free(handler);
}
Esempio n. 13
0
int gpio_init_int(gpio_t dev, gpio_pp_t pullup, gpio_flank_t flank, gpio_cb_t cb, void *arg)
{
    int res;
    uint8_t exti_line;
    uint8_t gpio_irq;

    /* configure pin as input */
    res = gpio_init_in(dev, pullup);
    if (res < 0) {
        return res;
    }

    /* set interrupt priority (its the same for all EXTI interrupts) */
    NVIC_SetPriority(EXTI0_IRQn, GPIO_IRQ_PRIO);
    NVIC_SetPriority(EXTI1_IRQn, GPIO_IRQ_PRIO);
    NVIC_SetPriority(EXTI2_IRQn, GPIO_IRQ_PRIO);
    NVIC_SetPriority(EXTI4_IRQn, GPIO_IRQ_PRIO);

    RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;

    /* read pin number, set EXTI channel and enable global interrupt for EXTI channel */
    switch (dev) {
#if GPIO_0_EN
        case GPIO_0:
            exti_line = GPIO_0_PIN;
            gpio_irq = GPIO_0;
            GPIO_0_EXTI_CFG();
            NVIC_SetPriority(GPIO_0_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_0_IRQ);
            break;
#endif
#if GPIO_1_EN
        case GPIO_1:
            exti_line = GPIO_1_PIN;
            gpio_irq = GPIO_1;
            GPIO_1_EXTI_CFG();
            NVIC_SetPriority(GPIO_1_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_1_IRQ);
            break;
#endif
#if GPIO_2_EN
        case GPIO_2:
            exti_line = GPIO_2_PIN;
            gpio_irq = GPIO_2;
            GPIO_2_EXTI_CFG();
            NVIC_SetPriority(GPIO_2_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_2_IRQ);
            break;
#endif
#if GPIO_3_EN
        case GPIO_3:
            exti_line = GPIO_3_PIN;
            gpio_irq = GPIO_3;
            GPIO_3_EXTI_CFG();
            NVIC_SetPriority(GPIO_3_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_3_IRQ);
            break;
#endif
#if GPIO_4_EN
        case GPIO_4:
            exti_line = GPIO_4_PIN;
            gpio_irq = GPIO_4;
            GPIO_4_EXTI_CFG();
            NVIC_SetPriority(GPIO_4_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_4_IRQ);
            break;
#endif
#if GPIO_5_EN
        case GPIO_5:
            exti_line = GPIO_5_PIN;
            gpio_irq = GPIO_5;
            GPIO_5_EXTI_CFG();
            NVIC_SetPriority(GPIO_5_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_5_IRQ);
            break;
#endif
#if GPIO_6_EN
        case GPIO_6:
            exti_line = GPIO_6_PIN;
            gpio_irq = GPIO_6;
            GPIO_6_EXTI_CFG();
            NVIC_SetPriority(GPIO_6_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_6_IRQ);
            break;
#endif
#if GPIO_7_EN
        case GPIO_7:
            exti_line = GPIO_7_PIN;
            gpio_irq = GPIO_7;
            GPIO_7_EXTI_CFG();
            NVIC_SetPriority(GPIO_7_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_7_IRQ);
            break;
#endif
#if GPIO_8_EN
        case GPIO_8:
            exti_line = GPIO_8_PIN;
            gpio_irq = GPIO_8;
            GPIO_8_EXTI_CFG();
            NVIC_SetPriority(GPIO_8_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_8_IRQ);
            break;
#endif
#if GPIO_9_EN
        case GPIO_9:
            exti_line = GPIO_9_PIN;
            gpio_irq = GPIO_9;
            GPIO_9_EXTI_CFG();
            NVIC_SetPriority(GPIO_9_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_9_IRQ);
            break;
#endif
#if GPIO_10_EN
        case GPIO_10:
            exti_line = GPIO_10_PIN;
            gpio_irq = GPIO_10;
            GPIO_10_EXTI_CFG();
            NVIC_SetPriority(GPIO_10_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_10_IRQ);
            break;
#endif
#if GPIO_11_EN
        case GPIO_11:
            exti_line = GPIO_11_PIN;
            gpio_irq = GPIO_11;
            GPIO_11_EXTI_CFG();
            NVIC_SetPriority(GPIO_11_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_11_IRQ);
            break;
#endif
#if GPIO_12_EN
        case GPIO_12:
            exti_line = GPIO_12_PIN;
            gpio_irq = GPIO_12;
            GPIO_12_EXTI_CFG();
            NVIC_SetPriority(GPIO_12_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_12_IRQ);
            break;
#endif
#if GPIO_13_EN
        case GPIO_13:
            exti_line = GPIO_13_PIN;
            gpio_irq = GPIO_13;
            GPIO_13_EXTI_CFG();
            NVIC_SetPriority(GPIO_13_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_13_IRQ);
            break;
#endif
#if GPIO_14_EN
        case GPIO_14:
            exti_line = GPIO_14_PIN;
            gpio_irq = GPIO_14;
            GPIO_14_EXTI_CFG();
            NVIC_SetPriority(GPIO_14_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_14_IRQ);
            break;
#endif
#if GPIO_15_EN
        case GPIO_15:
            exti_line = GPIO_15_PIN;
            gpio_irq = GPIO_15;
            GPIO_15_EXTI_CFG();
            NVIC_SetPriority(GPIO_15_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_15_IRQ);
            break;
#endif
        default:
            return -1;
    }

    /* set callback */
    config[gpio_irq].cb = cb;
    config[gpio_irq].arg = arg;

    /* configure the event that triggers an interrupt */
    switch (flank) {
        case GPIO_RISING:
            EXTI->RTSR |= (1 << exti_line);
            EXTI->FTSR &= ~(1 << exti_line);
            break;
        case GPIO_FALLING:
            EXTI->RTSR &= ~(1 << exti_line);
            EXTI->FTSR |= (1 << exti_line);
            break;
        case GPIO_BOTH:
            EXTI->RTSR |= (1 << exti_line);
            EXTI->FTSR |= (1 << exti_line);
            break;
    }

    /* clear event mask */
    EXTI->EMR &= ~(1 << exti_line);
    /* unmask the pins interrupt channel */
    EXTI->IMR |= (1 << exti_line);

    return 0;
}
Esempio n. 14
0
File: gpio.c Progetto: AnonMall/RIOT
int gpio_init_int(gpio_t dev, gpio_pp_t pullup, gpio_flank_t flank, gpio_cb_t cb, void *arg)
{
    int res;
    Pio *port = 0;
    uint32_t pin = 0;

    /* initialize port as input */
    res = gpio_init_in(dev, pullup);
    if (res < 0) {
        return res;
    }

    /* read port and enable port interrupts */
    switch (dev) {
#if GPIO_0_EN
        case GPIO_0:
            port = GPIO_0_DEV;
            pin = GPIO_0_PIN;
            NVIC_SetPriority(GPIO_0_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_0_IRQ);
            break;
#endif
#if GPIO_1_EN
        case GPIO_1:
            port = GPIO_1_DEV;
            pin = GPIO_1_PIN;
            NVIC_SetPriority(GPIO_1_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_1_IRQ);
            break;
#endif
#if GPIO_2_EN
        case GPIO_2:
            port = GPIO_2_DEV;
            pin = GPIO_2_PIN;
            NVIC_SetPriority(GPIO_2_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_2_IRQ);
            break;
#endif
#if GPIO_3_EN
        case GPIO_3:
            port = GPIO_3_DEV;
            pin = GPIO_3_PIN;
            NVIC_SetPriority(GPIO_3_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_3_IRQ);
            break;
#endif
#if GPIO_4_EN
        case GPIO_4:
            port = GPIO_4_DEV;
            pin = GPIO_4_PIN;
            NVIC_SetPriority(GPIO_4_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_4_IRQ);
            break;
#endif
#if GPIO_5_EN
        case GPIO_5:
            port = GPIO_5_DEV;
            pin = GPIO_5_PIN;
            NVIC_SetPriority(GPIO_5_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_5_IRQ);
            break;
#endif
#if GPIO_6_EN
        case GPIO_6:
            port = GPIO_6_DEV;
            pin = GPIO_6_PIN;
            NVIC_SetPriority(GPIO_6_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_6_IRQ);
            break;
#endif
#if GPIO_7_EN
        case GPIO_7:
            port = GPIO_7_DEV;
            pin = GPIO_7_PIN;
            NVIC_SetPriority(GPIO_7_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_7_IRQ);
            break;
#endif
#if GPIO_8_EN
        case GPIO_8:
            port = GPIO_8_DEV;
            pin = GPIO_8_PIN;
            NVIC_SetPriority(GPIO_8_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_8_IRQ);
            break;
#endif
#if GPIO_9_EN
        case GPIO_9:
            port = GPIO_9_DEV;
            pin = GPIO_9_PIN;
            NVIC_SetPriority(GPIO_9_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_9_IRQ);
            break;
#endif
#if GPIO_10_EN
        case GPIO_10:
            port = GPIO_10_DEV;
            pin = GPIO_10_PIN;
            NVIC_SetPriority(GPIO_10_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_10_IRQ);
            break;
#endif
#if GPIO_11_EN
        case GPIO_11:
            port = GPIO_11_DEV;
            pin = GPIO_11_PIN;
            NVIC_SetPriority(GPIO_11_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_11_IRQ);
            break;
#endif
#if GPIO_12_EN
        case GPIO_12:
            port = GPIO_12_DEV;
            pin = GPIO_12_PIN;
            NVIC_SetPriority(GPIO_12_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_12_IRQ);
            break;
#endif
#if GPIO_13_EN
        case GPIO_13:
            port = GPIO_13_DEV;
            pin = GPIO_13_PIN;
            NVIC_SetPriority(GPIO_13_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_13_IRQ);
            break;
#endif
#if GPIO_14_EN
        case GPIO_14:
            port = GPIO_14_DEV;
            pin = GPIO_14_PIN;
            NVIC_SetPriority(GPIO_14_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_14_IRQ);
            break;
#endif
#if GPIO_15_EN
        case GPIO_15:
            port = GPIO_15_DEV;
            pin = GPIO_15_PIN;
            NVIC_SetPriority(GPIO_15_IRQ, GPIO_IRQ_PRIO);
            NVIC_EnableIRQ(GPIO_15_IRQ);
            break;
#endif
    }

    /* set callback function and parameter */
    gpio_config[dev].cb = cb;
    gpio_config[dev].arg = arg;

    /* set the active flank */
    switch (flank) {
        case GPIO_FALLING:
            port->PIO_AIMER = pin;
            port->PIO_ESR = pin;
            port->PIO_FELLSR = pin;
            break;
        case GPIO_RISING:
            port->PIO_AIMER = pin;
            port->PIO_ESR = pin;
            port->PIO_REHLSR = pin;
            break;
        case GPIO_BOTH:
            port->PIO_AIMDR = pin;
            break;
    }

    /* clean interrupt status register */
    port->PIO_ISR;

    /* enable the interrupt for the given channel */
    port->PIO_IER = pin;

    return 0;
}
Esempio n. 15
0
int main(void)
{
  GPIO_0_CLKEN();
  gpio_init_out(GPIO_0, GPIO_NOPULL);
  GPIO_1_CLKEN();
  gpio_init_out(GPIO_1, GPIO_NOPULL);
  GPIO_2_CLKEN();
  gpio_init_out(GPIO_2, GPIO_NOPULL);
  GPIO_3_CLKEN();
  gpio_init_out(GPIO_3, GPIO_NOPULL);

  GPIO_9_CLKEN();
  gpio_init_in(GPIO_9, GPIO_PULLDOWN);
  GPIO_10_CLKEN();
  gpio_init_in(GPIO_10, GPIO_PULLDOWN);
  GPIO_11_CLKEN();
  gpio_init_in(GPIO_11, GPIO_PULLDOWN);

      gpio_set(GPIO_3);

      gpio_clear(GPIO_1);
      hwtimer_wait(HWTIMER_TICKS(500 * 1000));
      gpio_set(GPIO_0);
      gpio_set(GPIO_1);
      gpio_set(GPIO_2);

    while(1) {
      #if LEEEEDS
      gpio_clear(GPIO_1);
      hwtimer_wait(HWTIMER_TICKS(500 * 1000));

      gpio_clear(GPIO_0);
      hwtimer_wait(HWTIMER_TICKS(500 * 1000));
      gpio_clear(GPIO_2);
      hwtimer_wait(HWTIMER_TICKS(500 * 1000));
      gpio_set(GPIO_0);
      gpio_set(GPIO_1);
      gpio_set(GPIO_2);
      #endif

     if (gpio_read(GPIO_9))
      {
        gpio_clear(GPIO_0);
      }
      else
        {
          gpio_set(GPIO_0);
        }

        if (gpio_read(GPIO_10))
          {
            gpio_clear(GPIO_1);
          }
          else
            {
              gpio_set(GPIO_1);
            }
            
            if (gpio_read(GPIO_11))
              {
                gpio_clear(GPIO_2);
              }
              else
                {
                  gpio_set(GPIO_2);
                }
    }
    return 0;
}