Exemple #1
0
void gpio_irq_set(gpio_irq_t *obj, gpio_irq_event event, uint32_t enable)
{
    MBED_ASSERT(obj);
    Eic *const eic = _extint_get_eic_from_channel(obj->ch);
    if (enable) {
        if (event == IRQ_RISE) {
            obj->irqmask |= IRQ_RISE_POSITION;
        } else if (event == IRQ_FALL) {
            obj->irqmask |= IRQ_FALL_POSITION;
        }
        eic->INTENSET.reg = (1UL << obj->ch);
    } else {
        if (event == IRQ_RISE) {
            obj->irqmask &= ~IRQ_RISE_POSITION;
        } else if (event == IRQ_FALL) {
            obj->irqmask &= ~IRQ_FALL_POSITION;
        }
    }

    if (obj->irqmask == (IRQ_RISE_POSITION | IRQ_FALL_POSITION)) {
        pEXT_CONF(obj).detection_criteria = EXTINT_DETECT_BOTH;
    } else if (obj->irqmask == IRQ_RISE_POSITION) {
        pEXT_CONF(obj).detection_criteria = EXTINT_DETECT_RISING;
    } else if (obj->irqmask == IRQ_FALL_POSITION) {
        pEXT_CONF(obj).detection_criteria = EXTINT_DETECT_FALLING;
    } else {
        pEXT_CONF(obj).detection_criteria = EXTINT_DETECT_NONE;
        eic->INTENCLR.reg = (1UL << obj->ch);
    }

    extint_chan_set_config(obj->ch, &pEXT_CONF(obj));
}
Exemple #2
0
/*---------------------------------------------------------------------------*/
void
button_sensor_init(void)
{
  struct extint_chan_conf config_extint_chan;
  struct port_config pin_conf;
  port_get_config_defaults(&pin_conf);
  pin_conf.direction  = PORT_PIN_DIR_INPUT;
  pin_conf.input_pull = PORT_PIN_PULL_UP;
  port_pin_set_config(BUTTON_0_PIN, &pin_conf);

  //  extint_enable();
  extint_chan_get_config_defaults(&config_extint_chan);
  config_extint_chan.gpio_pin           = BUTTON_0_EIC_PIN;
  config_extint_chan.gpio_pin_mux       = BUTTON_0_EIC_MUX;
  config_extint_chan.gpio_pin_pull      = EXTINT_PULL_UP;
  config_extint_chan.detection_criteria = EXTINT_DETECT_FALLING;
  // config_extint_chan.detection_criteria = EXTINT_DETECT_BOTH;
  extint_chan_set_config(BUTTON_0_EIC_LINE, &config_extint_chan);

  extint_register_callback((extint_callback_t)extint_detection_callback,
                           BUTTON_0_EIC_LINE,
                           EXTINT_CALLBACK_TYPE_DETECT);
  extint_chan_enable_callback(BUTTON_0_EIC_LINE, EXTINT_CALLBACK_TYPE_DETECT);

  timer_set(&debouncetimer, 0);
  system_interrupt_enable_global();

  /* on by default */
  button_sensor_configure(0, 1);

}
Exemple #3
0
/**
 * \internal
 * \brief Test for external interrupt detection by polling.
 *
 * This test changes the logic level of PB05 from high to low
 * so that the external interrupt channel detects the edge.
 *
 * Detection is tested for both rising and falling edges.
 *
 * \param test Current test case.
 */
static void run_extint_polled_mode_test(const struct test_case *test)
{
	/* Testing the falling edge detection */
	/* Generate falling edge */
	port_pin_set_output_level(GPIO_TEST_PIN_EXTINT, false);
	/* Wait for the pin level to stabilize */
	delay_ms(1);
	result = extint_chan_is_detected(EIC_TEST_CHANNEL);
	test_assert_true(test, result,
			"External interrupt falling edge detection by polling failed");
	extint_chan_clear_detected(EIC_TEST_CHANNEL);

	/* Testing the rising edge detection */
	result = false;
	eic_conf.detection_criteria = EXTINT_DETECT_RISING;
	extint_chan_set_config(EIC_TEST_CHANNEL, &eic_conf);
	/* Generate rising edge */
	port_pin_set_output_level(GPIO_TEST_PIN_EXTINT, true);
	/* Wait for the pin level to stabilize */
	delay_ms(1);
	result = extint_chan_is_detected(EIC_TEST_CHANNEL);
	test_assert_true(test, result,
			"External interrupt rising edge detection by polling failed");
	extint_chan_clear_detected(EIC_TEST_CHANNEL);
}
Exemple #4
0
/*==============================================================================
 hal_extIntInit()
 =============================================================================*/
uint8_t hal_extIntInit( en_targetExtInt_t e_intSource,
        pfn_intCallb_t pfn_intCallback )
{
    int8_t c_ret = 0;

    if( pfn_intCallback != NULL )
    {
        switch( e_intSource )
        {
            case E_TARGET_RADIO_INT:
                //! [setup_init]
                //extint_enable();

                //! [conf_channel]
                //! [setup_1]
                extint_chan_get_config_defaults( &( radio_extInt.st_chan ) );
                //! [setup_1]

                //! [setup_2]
                radio_extInt.st_chan.gpio_pin = radio_extInt.l_pin; //EXT1_IRQ_PIN;
                radio_extInt.st_chan.gpio_pin_mux = radio_extInt.l_pinMux; //MUX_PB04A_EIC_EXTINT4;
                radio_extInt.st_chan.gpio_pin_pull = radio_extInt.c_pinPull; //EXTINT_PULL_DOWN;
                radio_extInt.st_chan.detection_criteria =
                        radio_extInt.c_detCrit; //EXTINT_DETECT_RISING;
                //! [setup_2]

                //! [setup_3]
                extint_chan_set_config( (uint8_t)radio_extInt.l_line,
                        &( radio_extInt.st_chan ) );
                //! [setup_3]

                _radio_callback = pfn_intCallback;
                //! [setup_4]
                extint_register_callback(
                        (extint_callback_t)_isr_radio_callback,
                        (uint8_t)radio_extInt.l_line,
                        EXTINT_CALLBACK_TYPE_DETECT );
                //! [setup_4]
                //! [setup_5]
                extint_chan_enable_callback( (uint8_t)radio_extInt.l_line, //EXT1_IRQ_INPUT,
                        EXTINT_CALLBACK_TYPE_DETECT );
                //! [setup_6]

                //! [conf_channel]
                //! [setup_init]
                system_interrupt_enable_global();
                c_ret = 1;
                break;
            case E_TARGET_USART_INT:
                break;
            default:
                break;
        }
    }
    return c_ret;

} /* hal_extIntInit() */
Exemple #5
0
/**
 * \internal
 * \brief Cleanup function for callback mode test.
 *
 * This function disables the callback & external interrupt channel.
 *
 * \param test Current test case.
 */
static void cleanup_extint_callback_mode_test(const struct test_case *test)
{
	eic_conf.detection_criteria = EXTINT_DETECT_NONE;
	extint_chan_set_config(EIC_TEST_CHANNEL, &eic_conf);
	/* Unregister and disable the callback function */
	extint_unregister_callback(extint_user_callback,
			EIC_TEST_CHANNEL,
			EXTINT_CALLBACK_TYPE_DETECT);
	extint_chan_disable_callback(EIC_TEST_CHANNEL,
			EXTINT_CALLBACK_TYPE_DETECT);
}
Exemple #6
0
/** Configures the External Interrupt Controller to detect changes in the board
 *  button state.
 */
static void configure_extint(void)
{
	struct extint_chan_conf eint_chan_conf;
	extint_chan_get_config_defaults(&eint_chan_conf);

	eint_chan_conf.gpio_pin           = BUTTON_0_EIC_PIN;
	eint_chan_conf.gpio_pin_mux       = BUTTON_0_EIC_MUX;
	eint_chan_conf.detection_criteria = EXTINT_DETECT_BOTH;
	eint_chan_conf.filter_input_signal = true;
	extint_chan_set_config(BUTTON_0_EIC_LINE, &eint_chan_conf);
}
Exemple #7
0
void configure_extint_channel(void)
{
	struct extint_chan_conf config_extint_chan;

	extint_chan_get_config_defaults(&config_extint_chan);

	config_extint_chan.gpio_pin           = PIN_PA02A_EIC_EXTINT2;
	config_extint_chan.gpio_pin_mux       = PINMUX_PA02A_EIC_EXTINT2;
	config_extint_chan.gpio_pin_pull      = EXTINT_PULL_DOWN;
	config_extint_chan.detection_criteria = EXTINT_DETECT_FALLING;

	extint_chan_set_config(2, &config_extint_chan);
}
void cph_deca_init_gpio(void) {
	struct extint_chan_conf config_chan;
	extint_chan_get_config_defaults(&config_chan);

	config_chan.gpio_pin = DW_IRQ_PIN;
	config_chan.gpio_pin_mux = DW_IRQ_PIN_MUX;
	config_chan.gpio_pin_pull = DW_IRQ_PIN_PULL;
	config_chan.detection_criteria = DW_IRQ_PIN_DETECT;

	extint_chan_set_config(DW_IRQ_LINE, &config_chan);

	extint_register_callback(cph_deca_isr, DW_IRQ_LINE, EXTINT_CALLBACK_TYPE_DETECT);
}
Exemple #9
0
/**
 * \internal
 * \brief Setup function for polled mode test.
 *
 * This function sets up the GPIO pin and the external interrupt channel.
 *
 * \param test Current test case.
 */
static void setup_extint_polled_mode_test(const struct test_case *test)
{
	/* Configure the GPIO pin */
	port_get_config_defaults(&pin_conf);
	pin_conf.direction  = PORT_PIN_DIR_OUTPUT;
	pin_conf.input_pull = PORT_PIN_PULL_NONE;
	port_pin_set_config(GPIO_TEST_PIN_EXTINT, &pin_conf);
	port_pin_set_output_level(GPIO_TEST_PIN_EXTINT, true);

	/* Configure the external interrupt channel */
	extint_chan_get_config_defaults(&eic_conf);
	eic_conf.gpio_pin           = EIC_TEST_PIN;
	eic_conf.gpio_pin_mux       = EIC_TEST_PIN_MUX;
	eic_conf.gpio_pin_pull      = EXTINT_PULL_UP;
	eic_conf.detection_criteria = EXTINT_DETECT_FALLING;
	extint_chan_set_config(EIC_TEST_CHANNEL, &eic_conf);
}
Exemple #10
0
static void configure_eic(void)
{
	struct extint_chan_conf config_extint_chan;
	extint_chan_get_config_defaults(&config_extint_chan);

	config_extint_chan.gpio_pin           = PIN_PA11A_EIC_EXTINT11;
	config_extint_chan.gpio_pin_mux       = PINMUX_PA11A_EIC_EXTINT11;
	config_extint_chan.gpio_pin_pull      = EXTINT_PULL_DOWN;
	config_extint_chan.detection_criteria = EXTINT_DETECT_HIGH;				
	extint_chan_set_config(11 , &config_extint_chan);
	
	struct extint_events conf_extint_event;
	memset(&conf_extint_event, 0, sizeof(struct extint_events));
	
	conf_extint_event.generate_event_on_detect[11] = true;
	extint_enable_events(&conf_extint_event);
}
void config_wind_speed()
{
    struct extint_chan_conf wind_speed_chan;

    extint_chan_get_config_defaults(&wind_speed_chan);

    wind_speed_chan.gpio_pin		= WIND_SPEED_INTERRUPT_PIN;
    wind_speed_chan.gpio_pin_mux	= WIND_SPEED_INTERRUPT_MUX;
    wind_speed_chan.gpio_pin_pull	= EXTINT_PULL_UP;
    wind_speed_chan.detection_criteria = EXTINT_DETECT_RISING;

    extint_chan_set_config(WIND_SPEED_INTERRUPT_LINE, &wind_speed_chan);
    extint_register_callback(wind_click_handle, WIND_SPEED_INTERRUPT_LINE, EXTINT_CALLBACK_TYPE_DETECT);
    extint_chan_enable_callback(WIND_SPEED_INTERRUPT_LINE, EXTINT_CALLBACK_TYPE_DETECT);

    return;
}
WEATHER_ERR_T config_rain_guage()
{
    struct extint_chan_conf rain_extint_chan;

    extint_chan_get_config_defaults(&rain_extint_chan);

    rain_extint_chan.gpio_pin		= RAIN_INTERRUPT_PIN;
    rain_extint_chan.gpio_pin_mux	= RAIN_INTERRUPT_MUX;
    rain_extint_chan.gpio_pin_pull	= EXTINT_PULL_UP;
    rain_extint_chan.detection_criteria = EXTINT_DETECT_RISING;

    extint_chan_set_config(RAIN_INTERRUPT_LINE, &rain_extint_chan);
    extint_register_callback(rain_click_handle, RAIN_INTERRUPT_LINE, EXTINT_CALLBACK_TYPE_DETECT);
    extint_chan_enable_callback(RAIN_INTERRUPT_LINE, EXTINT_CALLBACK_TYPE_DETECT);

    return W_ERR_NONE;
}
Exemple #13
0
/**
 * \brief Initializes and enables interrupt pin change
 */
static void ui_enable_asynchronous_interrupt(void)
{
	/* Initialize EIC for button wakeup */
	struct extint_chan_conf eint_chan_conf;
	extint_chan_get_config_defaults(&eint_chan_conf);

	eint_chan_conf.gpio_pin            = BUTTON_0_EIC_PIN;
	eint_chan_conf.gpio_pin_mux        = BUTTON_0_EIC_MUX;
	eint_chan_conf.detection_criteria  = EXTINT_DETECT_FALLING;
	eint_chan_conf.filter_input_signal = true;
	extint_chan_set_config(BUTTON_0_EIC_LINE, &eint_chan_conf);
	extint_register_callback(UI_WAKEUP_HANDLER,
			BUTTON_0_EIC_LINE,
			EXTINT_CALLBACK_TYPE_DETECT);
	extint_chan_clear_detected(BUTTON_0_EIC_LINE);
	extint_chan_enable_callback(BUTTON_0_EIC_LINE,
			EXTINT_CALLBACK_TYPE_DETECT);
}
Exemple #14
0
/*
 *	@fn		nm_bsp_register_isr
 *	@brief	Register interrupt service routine
 *	@param[IN]	pfIsr
 *				Pointer to ISR handler
 */
void nm_bsp_register_isr(tpfNmBspIsr pfIsr)
{
	struct extint_chan_conf config_extint_chan;

	gpfIsr = pfIsr;

	extint_chan_get_config_defaults(&config_extint_chan);
	config_extint_chan.gpio_pin = CONF_WINC_SPI_INT_PIN;
	config_extint_chan.gpio_pin_mux = CONF_WINC_SPI_INT_MUX;
	config_extint_chan.gpio_pin_pull = EXTINT_PULL_UP;
	config_extint_chan.detection_criteria = EXTINT_DETECT_FALLING;

	extint_chan_set_config(CONF_WINC_SPI_INT_EIC, &config_extint_chan);
	extint_register_callback(chip_isr, CONF_WINC_SPI_INT_EIC,
			EXTINT_CALLBACK_TYPE_DETECT);
	extint_chan_enable_callback(CONF_WINC_SPI_INT_EIC,
			EXTINT_CALLBACK_TYPE_DETECT);
}
Exemple #15
0
//! [config_eic]
static void configure_eic(void)
{
	//! [eic_chan_setup]
	//! [eic_setup_1]
	struct extint_chan_conf config;
	//! [eic_setup_1]
	//! [eic_setup_2]
	extint_chan_get_config_defaults(&config);
	//! [eic_setup_2]
	//! [eic_setup_3]
	config.filter_input_signal = true;
	config.detection_criteria  = EXTINT_DETECT_BOTH;
	config.gpio_pin     = CONF_FAULT_EIC_PIN;
	config.gpio_pin_mux = CONF_FAULT_EIC_PIN_MUX;
	//! [eic_setup_3]
	//! [eic_setup_4]
	extint_chan_set_config(CONF_FAULT_EIC_LINE, &config);
	//! [eic_setup_4]
	//! [eic_chan_setup]

	//! [eic_event_setup]
	//! [eic_event_setup_1]
	struct extint_events events;
	memset(&events, 0, sizeof(struct extint_events));
	//! [eic_event_setup_1]
	//! [eic_event_setup_2]
	events.generate_event_on_detect[CONF_FAULT_EIC_LINE] = true;
	//! [eic_event_setup_2]
	//! [eic_event_setup_3]
	extint_enable_events(&events);
	//! [eic_event_setup_3]
	//! [eic_event_setup]

	//! [eic_callback_setup]
	//! [eic_callback_setup_1]
	extint_register_callback(eic_callback_to_clear_halt,
			CONF_FAULT_EIC_LINE, EXTINT_CALLBACK_TYPE_DETECT);
	//! [eic_callback_setup_1]
	//! [eic_callback_setup_2]
	extint_chan_enable_callback(CONF_FAULT_EIC_LINE,
			EXTINT_CALLBACK_TYPE_DETECT);
	//! [eic_callback_setup_2]
	//! [eic_callback_setup]
}
Exemple #16
0
void ui_init(void)
{
	struct extint_chan_conf config_extint_chan;

	extint_chan_get_config_defaults(&config_extint_chan);

	config_extint_chan.gpio_pin            = BUTTON_0_EIC_PIN;
	config_extint_chan.gpio_pin_mux        = BUTTON_0_EIC_MUX;
	config_extint_chan.gpio_pin_pull       = EXTINT_PULL_UP;
	config_extint_chan.filter_input_signal = true;
	config_extint_chan.detection_criteria  = EXTINT_DETECT_FALLING;
	extint_chan_set_config(BUTTON_0_EIC_LINE, &config_extint_chan);
	extint_register_callback(ui_wakeup_handler, BUTTON_0_EIC_LINE,
			EXTINT_CALLBACK_TYPE_DETECT);
	extint_chan_enable_callback(BUTTON_0_EIC_LINE,EXTINT_CALLBACK_TYPE_DETECT);

	/* Initialize LEDs */
	LED_On(LED_0_PIN);
}
Exemple #17
0
/**
 * USB ID pin configuration
 */
static void usb_id_config(void)
{
	struct extint_chan_conf eint_chan_conf;
	extint_chan_get_config_defaults(&eint_chan_conf);

	eint_chan_conf.gpio_pin           = USB_ID_PIN;
	eint_chan_conf.gpio_pin_mux       = USB_ID_EIC_MUX;
	eint_chan_conf.detection_criteria = EXTINT_DETECT_BOTH;
	eint_chan_conf.filter_input_signal = true;

	extint_chan_disable_callback(USB_ID_EIC_LINE,
			EXTINT_CALLBACK_TYPE_DETECT);
	extint_chan_set_config(USB_ID_EIC_LINE, &eint_chan_conf);
	extint_register_callback(usb_id_handler,
			USB_ID_EIC_LINE,
			EXTINT_CALLBACK_TYPE_DETECT);
	extint_chan_enable_callback(USB_ID_EIC_LINE,
			EXTINT_CALLBACK_TYPE_DETECT);
}
//! [setup]
void configure_extint_channel(void)
{
//! [setup_1]
    struct extint_chan_conf config_extint_chan;
//! [setup_1]
//! [setup_2]
    extint_chan_get_config_defaults(&config_extint_chan);
//! [setup_2]

//! [setup_3]
    config_extint_chan.gpio_pin           = BUTTON_0_EIC_PIN;
    config_extint_chan.gpio_pin_mux       = BUTTON_0_EIC_MUX;
    config_extint_chan.gpio_pin_pull      = EXTINT_PULL_UP;
    config_extint_chan.detection_criteria = EXTINT_DETECT_BOTH;
//! [setup_3]
//! [setup_4]
    extint_chan_set_config(BUTTON_0_EIC_LINE, &config_extint_chan);
//! [setup_4]
}
void configurationPPS(void){

		struct extint_chan_conf eint_chan_conf;
		extint_chan_get_config_defaults(&eint_chan_conf);
		// put the button as EXTINT
		eint_chan_conf.gpio_pin           = PIN_PA28A_EIC_EXTINT8;
		eint_chan_conf.gpio_pin_mux       = MUX_PA28A_EIC_EXTINT8;
		/** Detect rising signal edges */	 
		eint_chan_conf.detection_criteria = EXTINT_DETECT_RISING;
		eint_chan_conf.filter_input_signal = false;
		extint_chan_set_config(8, &eint_chan_conf);
		//configuration callback
		extint_register_callback(ppsISR,8,EXTINT_CALLBACK_TYPE_DETECT);
		//activation callback
		extint_chan_enable_callback(8,EXTINT_CALLBACK_TYPE_DETECT);
		pin_state=false;
	
		
}
/**
 * \brief Configure the INTN interrupt.
 *
 * \param p_handler callback pointer to use when INTN interrupt raises.
 */
void configure_intn(void (*p_handler) (void))
{
	struct extint_chan_conf eic_conf;

	/* Configure the external interrupt channel. */
	extint_chan_get_config_defaults(&eic_conf);
	eic_conf.gpio_pin            = KSZ8851SNL_INTN_EIC_PIN;
	eic_conf.gpio_pin_mux        = KSZ8851SNL_INTN_EIC_PIN_MUX;
	eic_conf.gpio_pin_pull       = EXTINT_PULL_UP;
	eic_conf.detection_criteria  = EXTINT_DETECT_FALLING;
	eic_conf.filter_input_signal = true;
	extint_chan_set_config(KSZ8851SNL_INTN_EIC_CHANNEL, &eic_conf);

	/* Register and enable the callback function. */
	extint_register_callback(p_handler,
			KSZ8851SNL_INTN_EIC_CHANNEL,
			EXTINT_CALLBACK_TYPE_DETECT);
	extint_chan_enable_callback(KSZ8851SNL_INTN_EIC_CHANNEL,
			EXTINT_CALLBACK_TYPE_DETECT);
}
Exemple #21
0
static int
button_sensor_configure(int type, int value)
{
  struct extint_chan_conf config_extint_chan;
  extint_chan_get_config_defaults(&config_extint_chan);
  config_extint_chan.gpio_pin           = BUTTON_0_EIC_PIN;
  config_extint_chan.gpio_pin_mux       = BUTTON_0_EIC_MUX;
  config_extint_chan.gpio_pin_pull      = EXTINT_PULL_UP;

  if(value == 1) {
    /* Enable the sensor */
    config_extint_chan.detection_criteria = EXTINT_DETECT_FALLING;
    //config_extint_chan.detection_criteria = EXTINT_DETECT_BOTH;
    enabled = 1;
  } else {
    /* Disable the sensor */
    config_extint_chan.detection_criteria = EXTINT_DETECT_NONE;
    enabled = 0;
  }
  extint_chan_set_config(BUTTON_0_EIC_LINE, &config_extint_chan);

  return 0;
}
Exemple #22
0
/**
 * \internal
 * \brief Test for external interrupt detection using callback.
 *
 * This test changes the logic level of PB05 from high to low
 * so that the external interrupt channel detects the edge
 * and calls the callback function.
 *
 * Detection is tested for both rising and falling edges.
 *
 * \param test Current test case.
 */
static void run_extint_callback_mode_test(const struct test_case *test)
{
	uint16_t timeout_cycles;

	/* Testing the falling edge detection */
	interrupt_flag = false;
	timeout_cycles = 100;
	port_pin_set_output_level(GPIO_TEST_PIN_EXTINT, false);
	do {
		timeout_cycles--;
		if (interrupt_flag) {
			break;
		}
	} while (timeout_cycles != 0);
	test_assert_true(test, timeout_cycles > 0,
			"Timeout in interrupt detection");
	test_assert_true(test, interrupt_flag,
			"External interrupt falling edge detection failed");

	/* Testing the rising edge detection */
	eic_conf.detection_criteria = EXTINT_DETECT_RISING;
	extint_chan_set_config(EIC_TEST_CHANNEL, &eic_conf);
	interrupt_flag = false;
	timeout_cycles = 100;
	port_pin_set_output_level(GPIO_TEST_PIN_EXTINT, true);
	do {
		timeout_cycles--;
		if (interrupt_flag) {
			break;
		}
	} while (timeout_cycles != 0);
	test_assert_true(test, timeout_cycles > 0,
			"Timeout in interrupt detection");
	test_assert_true(test, interrupt_flag,
			"External interrupt rising edge detection failed");
}
Exemple #23
0
int gpio_irq_init(gpio_irq_t *obj, PinName pin, gpio_irq_handler handler, uint32_t id)
{
    MBED_ASSERT(obj);
    if (pin == NC)
        return -1;

    IRQn_Type irq_n = (IRQn_Type)0;
    uint32_t vector = 0;
    int int_channel = 0;
    irq_handler = handler;  // assuming the usage of these apis in mbed layer only

    obj->pin = pin;

    extint_chan_get_config_defaults(&pEXT_CONF(obj));
    pEXT_CONF(obj).gpio_pin           = (uint32_t)pin;
    pEXT_CONF(obj).gpio_pin_mux       = 0;   // mux setting for ext int is 0
    pEXT_CONF(obj).gpio_pin_pull      = EXTINT_PULL_UP;
    pEXT_CONF(obj).detection_criteria = EXTINT_DETECT_NONE;

    int_channel = pinmap_find_peripheral(pin, PinMap_EXTINT);
    if (int_channel == NC) {
        return -1;
    }
    extint_chan_set_config(int_channel, &pEXT_CONF(obj));
    ext_int_pins[int_channel] = pin;

    irq_n = EIC_IRQn;
    vector = (uint32_t)gpio_irq;
    NVIC_SetVector(irq_n, vector);
    NVIC_EnableIRQ(irq_n);
    obj->ch = int_channel;
    channel_ids[int_channel] = id;
    obj->irqmask = 0;

    return 0;
}
Exemple #24
0
/*---------------------------------------------------------------------------*/
static void
configure_button(void)
{
  /* Set buttons as inputs */
  struct port_config pin_conf;
  port_get_config_defaults(&pin_conf);
  pin_conf.direction  = PORT_PIN_DIR_INPUT;
  pin_conf.input_pull = PORT_PIN_PULL_UP;
  port_pin_set_config(BUTTON_0_PIN, &pin_conf);

  /* Configure interrupt */
  struct extint_chan_conf config_extint_chan;
  extint_chan_get_config_defaults(&config_extint_chan);
  config_extint_chan.gpio_pin           = BUTTON_0_EIC_PIN;
  config_extint_chan.gpio_pin_mux       = BUTTON_0_EIC_MUX;
  config_extint_chan.gpio_pin_pull      = EXTINT_PULL_UP;
  config_extint_chan.detection_criteria = EXTINT_DETECT_BOTH;
  extint_chan_set_config(BUTTON_0_EIC_LINE, &config_extint_chan);

  /* Register interrupt callbacks */
  extint_register_callback(extint_detection_callback,
                           BUTTON_0_EIC_LINE,
                           EXTINT_CALLBACK_TYPE_DETECT);
}
Exemple #25
0
/**
 * \internal
 * \brief Test capture and compare
 *
 * This test uses TCC0 as a PWM generator (compare function). TCC1 will be set
 * to capture the signal from TCC0 to test the capture functionality.
 *
 * \param test Current test case.
 */
static void run_capture_and_compare_test(const struct test_case *test)
{
	test_assert_true(test,
			tcc_init_success == true,
			"TCC initialization failed, skipping test");

	test_assert_true(test,
			callback_function_entered == 1,
			"The callback test has failed, skipping test");

	/* Configure TCC module for PWM generation */
	tcc_reset(&tcc_test0_module);
	tcc_get_config_defaults(&tcc_test0_config, CONF_TEST_TCC0);
	tcc_test0_config.counter.period = 0x03FF;
	tcc_test0_config.compare.wave_generation  =
			TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
	tcc_test0_config.compare.match[TCC_MATCH_CAPTURE_CHANNEL_0]  = 0x01FF;

	/* Calculate the theoretical PWM frequency & duty */
	uint32_t frequency_output, duty_output;
	frequency_output = system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M) / (0x03FF+1);

	/* This value is depend on the WaveGeneration Mode */
	duty_output = (uint32_t)(tcc_test0_config.compare.match[TCC_MATCH_CAPTURE_CHANNEL_0] * 100) /
			tcc_test0_config.counter.period;

	tcc_test0_config.pins.enable_wave_out_pin[TCC_MATCH_CAPTURE_CHANNEL_0] = true;
	tcc_test0_config.pins.wave_out_pin[TCC_MATCH_CAPTURE_CHANNEL_0]        = CONF_TEST_PIN_OUT;
	tcc_test0_config.pins.wave_out_pin_mux[TCC_MATCH_CAPTURE_CHANNEL_0]    = CONF_TEST_PIN_MUX;
	tcc_init(&tcc_test0_module, CONF_TEST_TCC0, &tcc_test0_config);

	tcc_register_callback(&tcc_test0_module, tcc_callback_function, TCC_CALLBACK_CHANNEL_0);
	tcc_enable_callback(&tcc_test0_module, TCC_CALLBACK_CHANNEL_0);

	/* Configure TCC module for capture */
	tcc_reset(&tcc_test1_module);
	tcc_get_config_defaults(&tcc_test1_config, CONF_TEST_TCC1);
	tcc_test1_config.counter.period          = 0xFFFF;
	tcc_test1_config.counter.clock_prescaler = TCC_CLOCK_PRESCALER_DIV1;
	tcc_test1_config.capture.channel_function[CONF_CAPTURE_CHAN_0] = TCC_CHANNEL_FUNCTION_CAPTURE;
	tcc_test1_config.capture.channel_function[CONF_CAPTURE_CHAN_1] = TCC_CHANNEL_FUNCTION_CAPTURE;

	tcc_init(&tcc_test1_module, CONF_TEST_TCC1, &tcc_test1_config);

	struct tcc_events tcc_events = {
		.on_input_event_perform_action[1] = true,
		.input_config[1].modify_action = true,
		.input_config[1].action = TCC_EVENT_ACTION_PERIOD_PULSE_WIDTH_CAPTURE
	};

	tcc_enable_events(&tcc_test1_module, &tcc_events);

	/* Configure external interrupt controller */
	struct extint_chan_conf extint_chan_config;
	extint_chan_config.gpio_pin            = CONF_EIC_PIN;
	extint_chan_config.gpio_pin_mux        = CONF_EIC_MUX;
	extint_chan_config.gpio_pin_pull       = EXTINT_PULL_UP;
	extint_chan_config.wake_if_sleeping    = false;
	extint_chan_config.filter_input_signal = false;
	extint_chan_config.detection_criteria  = EXTINT_DETECT_HIGH;
	extint_chan_set_config(CONF_EIC_CHAN, &extint_chan_config);

	/* Configure external interrupt module to be event generator */
	struct extint_events extint_event_conf;
	extint_event_conf.generate_event_on_detect[CONF_EIC_CHAN] = true;
	extint_enable_events(&extint_event_conf);

	/* Configure event system */
	struct events_resource event_res;

	/* Configure channel */
	struct events_config config;
	events_get_config_defaults(&config);
	config.generator      = CONF_EVENT_GENERATOR_ID;
	config.edge_detect    = EVENTS_EDGE_DETECT_NONE;
	config.path           = EVENTS_PATH_ASYNCHRONOUS;
	events_allocate(&event_res, &config);

	/* Configure user */
	events_attach_user(&event_res, CONF_EVENT_USED_ID);

	/* Enable TCC modules */
	tcc_enable(&tcc_test1_module);
	tcc_enable(&tcc_test0_module);

	uint16_t period_after_capture = 0;
	uint16_t pulse_width_after_capture = 0;
	uint32_t capture_frequency = 0;
	uint32_t capture_duty = 0;

	while (callback_function_entered < 4) {
		period_after_capture = tcc_get_capture_value(&tcc_test1_module,
				TCC_MATCH_CAPTURE_CHANNEL_0);
		pulse_width_after_capture = tcc_get_capture_value(&tcc_test1_module,
				TCC_MATCH_CAPTURE_CHANNEL_1);
	}

	if(period_after_capture != 0) {
		capture_frequency =
				system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M) /
				period_after_capture;
		capture_duty = (uint32_t)(pulse_width_after_capture) * 100 /
				period_after_capture;
	}

	test_assert_true(test,
			(capture_frequency <= (frequency_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
			(capture_frequency >= (frequency_output * (100 - CONF_TEST_TOLERANCE) / 100)) && \
			(capture_duty <= (duty_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
			(capture_duty >= (duty_output * (100 - CONF_TEST_TOLERANCE) / 100)) \
			,"The result of Capture is wrong, captured frequency: %ldHz, captured duty: %ld%%",
			capture_frequency,
			capture_duty
			);
}

/**
 * \internal
 * \brief Test Recoverable Fault (FAULTn)
 *
 * This test uses TCC0 as a PWM generator (compare function).
 * EXTINT will be used to route fault input to TCC0.
 *
 * \param test Current test case.
 */
static void run_faultn_test(const struct test_case *test)
{
	test_assert_true(test,
			tcc_init_success == true,
			"TCC initialization failed, skipping test");

	/* Configure TCC module for PWM generation with fault */
	tcc_reset(&tcc_test0_module);
	tcc_get_config_defaults(&tcc_test0_config, CONF_TEST_TCC0);
	tcc_test0_config.counter.period = 0x03FF;
	tcc_test0_config.compare.wave_generation  =
			TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
	tcc_test0_config.compare.match[TCC_MATCH_CAPTURE_CHANNEL_0]  = 0x01FF;
	tcc_test0_config.wave_ext.recoverable_fault[TCC_MATCH_CAPTURE_CHANNEL_0].source = TCC_FAULT_SOURCE_ENABLE;
	tcc_test0_config.wave_ext.recoverable_fault[TCC_MATCH_CAPTURE_CHANNEL_0].halt_action = TCC_FAULT_HALT_ACTION_SW_HALT;
	tcc_init(&tcc_test0_module, CONF_TEST_TCC0, &tcc_test0_config);
	/* Configure TCC events for recoverable fault input */
	struct tcc_events tcc_test_events;
	memset(&tcc_test_events, 0, sizeof(struct tcc_events));
	tcc_test_events.on_event_perform_channel_action[TCC_MATCH_CAPTURE_CHANNEL_0] = true;
	tcc_enable_events(&tcc_test0_module, &tcc_test_events);
	tcc_enable(&tcc_test0_module);

	/* Configure IO pin to generate fault */
	struct port_config config_pin;
	port_get_config_defaults(&config_pin);
	config_pin.direction = PORT_PIN_DIR_OUTPUT;
	port_pin_set_config(CONF_TEST_PIN_OUT, &config_pin);
	port_pin_set_output_level(CONF_TEST_PIN_OUT, true);

	/* Configure EIC to capture fault input */
	struct extint_chan_conf config;
	extint_chan_get_config_defaults(&config);
	config.filter_input_signal = true;
	config.detection_criteria  = EXTINT_DETECT_BOTH;
	config.gpio_pin     = CONF_EIC_PIN;
	config.gpio_pin_mux = CONF_EIC_MUX;
	extint_chan_set_config(CONF_EIC_CHAN, &config);

	struct extint_events extint_test_events;
	memset(&extint_test_events, 0, sizeof(struct extint_events));
	extint_test_events.generate_event_on_detect[CONF_EIC_CHAN] = true;
	extint_enable_events(&extint_test_events);

	/* Configure EVENTs to route fault input */
	struct events_resource event_resource;
	struct events_config event_config;
	events_get_config_defaults(&event_config);
	event_config.generator = CONF_EVENT_GENERATOR_ID;
	event_config.path      = EVENTS_PATH_ASYNCHRONOUS;
	events_allocate(&event_resource, &event_config);
	events_attach_user(&event_resource, CONF_EVENT_USER_ID_FAULTn);

	/* Clear halt status */
	tcc_clear_status(&tcc_test0_module,
			TCC_STATUS_RECOVERABLE_FAULT_PRESENT(0) |
			TCC_STATUS_RECOVERABLE_FAULT_OCCUR(0));

	uint32_t test_val1 = tcc_get_count_value(&tcc_test0_module);
	uint32_t test_val2 = tcc_get_count_value(&tcc_test0_module);

	/* Check TCC is running */
	test_assert_true(test,
			test_val1 != test_val2,
			"The counter failed to stop on recoverable fault");

	/* Set fault */
	port_pin_set_output_level(CONF_TEST_PIN_OUT, false);

	/* Check fault state */
	test_assert_true(test,
			TCC_STATUS_RECOVERABLE_FAULT_OCCUR(0) &
					tcc_get_status(&tcc_test0_module),
			"The counter failed to detect recoverable fault");

	/* Check TCC is running */
	test_val1 = tcc_get_count_value(&tcc_test0_module);
	test_val2 = tcc_get_count_value(&tcc_test0_module);
	test_assert_true(test,
			test_val1 == test_val2,
			"The counter failed to stop on recoverable fault");
}
Exemple #26
0
/**
 * \internal
 * \brief Test Non-Recoverable Fault (FAULTx)
 *
 * This test uses TCC0 as a PWM generator (compare function).
 * EXTINT will be used to route fault input to TCC0.
 *
 * \param test Current test case.
 */
static void run_faultx_test(const struct test_case *test)
{
	test_assert_true(test,
	tcc_init_success == true,
	"TCC initialization failed, skipping test");

	/* Configure TCC module for PWM generation with fault */
	tcc_reset(&tcc_test0_module);
	tcc_get_config_defaults(&tcc_test0_config, CONF_TEST_TCC0);
	tcc_test0_config.counter.period = 0x03FF;
	tcc_test0_config.compare.wave_generation  =
	TCC_WAVE_GENERATION_SINGLE_SLOPE_PWM;
	tcc_test0_config.compare.match[TCC_MATCH_CAPTURE_CHANNEL_0]  = 0x01FF;
	tcc_test0_config.wave_ext.non_recoverable_fault[TCC_WAVE_OUTPUT_0].output = TCC_FAULT_STATE_OUTPUT_1;
	tcc_init(&tcc_test0_module, CONF_TEST_TCC0, &tcc_test0_config);
	/* Configure TCC events for non-recoverable fault input */
	struct tcc_events tcc_test_events;
	memset(&tcc_test_events, 0, sizeof(struct tcc_events));
	tcc_test_events.on_input_event_perform_action[0] = true;
	tcc_test_events.input_config[0].modify_action = true;
	tcc_test_events.input_config[0].action = TCC_EVENT_ACTION_NON_RECOVERABLE_FAULT;
	tcc_enable_events(&tcc_test0_module, &tcc_test_events);
	tcc_enable(&tcc_test0_module);

	/* Configure IO pin to generate fault */
	struct port_config config_pin;
	port_get_config_defaults(&config_pin);
	config_pin.direction = PORT_PIN_DIR_OUTPUT;
	port_pin_set_config(CONF_TEST_PIN_OUT, &config_pin);
	port_pin_set_output_level(CONF_TEST_PIN_OUT, true);

	/* Configure EIC to capture fault input */
	struct extint_chan_conf config;
	extint_chan_get_config_defaults(&config);
	config.filter_input_signal = true;
	config.detection_criteria  = EXTINT_DETECT_BOTH;
	config.gpio_pin     = CONF_EIC_PIN;
	config.gpio_pin_mux = CONF_EIC_MUX;
	extint_chan_set_config(CONF_EIC_CHAN, &config);

	struct extint_events extint_test_events;
	memset(&extint_test_events, 0, sizeof(struct extint_events));
	extint_test_events.generate_event_on_detect[CONF_EIC_CHAN] = true;
	extint_enable_events(&extint_test_events);

	/* Configure EVENTs to route fault input */
	struct events_resource event_resource;
	struct events_config event_config;
	events_get_config_defaults(&event_config);
	event_config.generator = CONF_EVENT_GENERATOR_ID;
	event_config.path      = EVENTS_PATH_ASYNCHRONOUS;
	events_allocate(&event_resource, &event_config);
	events_attach_user(&event_resource, CONF_EVENT_USER_ID_FAULTx);

	/* Clear halt status */
	tcc_clear_status(&tcc_test0_module,
			TCC_STATUS_NON_RECOVERABLE_FAULT_PRESENT(0) |
			TCC_STATUS_NON_RECOVERABLE_FAULT_OCCUR(0));

	uint32_t test_val1 = tcc_get_count_value(&tcc_test0_module);
	uint32_t test_val2 = tcc_get_count_value(&tcc_test0_module);

	/* Check TCC is running */
	test_assert_true(test,
			test_val1 != test_val2,
			"The counter failed to stop on non-recoverable fault");

	/* Set fault */
	port_pin_set_output_level(CONF_TEST_PIN_OUT, false);

	/* Check fault state */
	test_assert_true(test,
				TCC_STATUS_NON_RECOVERABLE_FAULT_OCCUR(0) &
						tcc_get_status(&tcc_test0_module),
				"The counter failed to detect non-recoverable fault");

	/* Check TCC is running */
	test_val1 = tcc_get_count_value(&tcc_test0_module);
	test_val2 = tcc_get_count_value(&tcc_test0_module);
	test_assert_true(test,
			test_val1 == test_val2,
			"The counter failed to stop on non-recoverable fault");
}
Exemple #27
0
/**
 * \internal
 * \brief Test capture and compare
 *
 * This test uses TC module 0 as a PWM generator (compare function).
 * TC module 1 will be set to capture the signal from TC module 0 to test the capture
 * functionality.
 *
 * \param test Current test case.
 */
static void run_16bit_capture_and_compare_test(const struct test_case *test)
{
	test_assert_true(test,
			tc_init_success == true,
			"TC initialization failed, skipping test");

	test_assert_true(test,
			callback_function_entered == 1,
			"The callback test has failed, skipping test");

	/* Configure 16-bit TC module for PWM generation */
	tc_reset(&tc_test0_module);
	tc_get_config_defaults(&tc_test0_config);
	tc_test0_config.wave_generation  = TC_WAVE_GENERATION_MATCH_PWM;
	tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_0]  = 0x03FF;
	tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_1]  = 0x01FF;

	/* Calculate the theoretical PWM frequency & duty */
	uint32_t frequency_output, duty_output;
	frequency_output = system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M)/ (0x03FF+1);

	/* This value is depend on the WaveGeneration Mode */
	duty_output = (uint32_t)(tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_1]) * 100 \
					/ tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_0];

	tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].enabled = true;
	tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].pin_out = CONF_TEST_PIN_OUT;
	tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].pin_mux = CONF_TEST_PIN_MUX;
	tc_init(&tc_test0_module, CONF_TEST_TC0, &tc_test0_config);

	tc_register_callback(&tc_test0_module, tc_callback_function, TC_CALLBACK_CC_CHANNEL0);
	tc_enable_callback(&tc_test0_module, TC_CALLBACK_CC_CHANNEL0);

	/* Configure 16-bit TC module for capture */
	tc_reset(&tc_test1_module);
	tc_get_config_defaults(&tc_test1_config);
	tc_test1_config.clock_prescaler              = TC_CLOCK_PRESCALER_DIV1;
	tc_test1_config.enable_capture_on_channel[CONF_CAPTURE_CHAN_0] = true;
	tc_test1_config.enable_capture_on_channel[CONF_CAPTURE_CHAN_1] = true;

	tc_init(&tc_test1_module, CONF_TEST_TC1, &tc_test1_config);

	struct tc_events tc_events = { .on_event_perform_action = true,
								.event_action = TC_EVENT_ACTION_PPW,};

	tc_enable_events(&tc_test1_module, &tc_events);

	/* Configure external interrupt controller */
	struct extint_chan_conf extint_chan_config;
	extint_chan_config.gpio_pin            = CONF_EIC_PIN;
	extint_chan_config.gpio_pin_mux        = CONF_EIC_MUX;
	extint_chan_config.gpio_pin_pull       = EXTINT_PULL_UP;
	extint_chan_config.wake_if_sleeping    = false;
	extint_chan_config.filter_input_signal = false;
	extint_chan_config.detection_criteria  = EXTINT_DETECT_HIGH;
	extint_chan_set_config(0, &extint_chan_config);

	/* Configure external interrupt module to be event generator */
	struct extint_events extint_event_conf;
	extint_event_conf.generate_event_on_detect[0] = true;
	extint_enable_events(&extint_event_conf);

	/* Configure event system */
	struct events_resource event_res;

	/* Configure channel */
	struct events_config config;
	events_get_config_defaults(&config);
	config.generator      = CONF_EVENT_GENERATOR_ID;
	config.edge_detect    = EVENTS_EDGE_DETECT_NONE;
	config.path           = EVENTS_PATH_ASYNCHRONOUS;
	events_allocate(&event_res, &config);

	/* Configure user */
	events_attach_user(&event_res, CONF_EVENT_USED_ID);

	/* Enable TC modules */
	tc_enable(&tc_test1_module);
	tc_enable(&tc_test0_module);

	uint16_t period_after_capture = 0;
	uint16_t pulse_width_after_capture = 0;
	uint32_t capture_frequency = 0;
	uint32_t capture_duty = 0;


	while (callback_function_entered < 4) {
		period_after_capture = tc_get_capture_value(&tc_test1_module,
				TC_COMPARE_CAPTURE_CHANNEL_0);
		pulse_width_after_capture = tc_get_capture_value(&tc_test1_module,
				TC_COMPARE_CAPTURE_CHANNEL_1);
	}

	if(period_after_capture != 0) {
		capture_frequency = system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M)/ period_after_capture;
		capture_duty = (uint32_t)(pulse_width_after_capture) * 100 / period_after_capture;
	}

	test_assert_true(test,
			(capture_frequency <= (frequency_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
			(capture_frequency >= (frequency_output * (100 - CONF_TEST_TOLERANCE) / 100)) && \
			(capture_duty <= (duty_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
			(capture_duty >= (duty_output * (100 - CONF_TEST_TOLERANCE) / 100)) \
			,"The result of Capture is wrong, captured frequency: %ldHz, captured duty: %ld%%",
			capture_frequency,
			capture_duty
			);
}

/**
 * \brief Initialize the USART for unit test
 *
 * Initializes the SERCOM USART used for sending the unit test status to the
 * computer via the EDBG CDC gateway.
 */
static void cdc_uart_init(void)
{
	struct usart_config usart_conf;

	/* Configure USART for unit test output */
	usart_get_config_defaults(&usart_conf);
	usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;
	usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;
	usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;
	usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;
	usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;
	usart_conf.baudrate    = CONF_STDIO_BAUDRATE;

	stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART, &usart_conf);
	usart_enable(&cdc_uart_module);
}

/**
 * \brief Run TC unit tests
 *
 * Initializes the system and serial output, then sets up the TC unit test
 * suite and runs it.
 */
int main(void)
{
	system_init();
	cdc_uart_init();

	/* Define Test Cases */
	DEFINE_TEST_CASE(init_test, NULL,
			run_init_test, NULL,
			"Initialize tc_xmodules");

	DEFINE_TEST_CASE(basic_functionality_test, NULL,
			run_basic_functionality_test, NULL,
			"test start stop and getters and setters");

	DEFINE_TEST_CASE(callback_test, NULL,
			run_callback_test, NULL,
			"test callback API");

	DEFINE_TEST_CASE(reset_32bit_master_test, NULL,
			run_reset_32bit_master_test, NULL,
			"Setup, reset and reinitialize TC modules of a 32-bit TC");


	DEFINE_TEST_CASE(capture_and_compare_test, NULL,
			run_16bit_capture_and_compare_test, NULL,
			"Test capture and compare");

	/* Put test case addresses in an array */
	DEFINE_TEST_ARRAY(tc_tests) = {
		&init_test,
		&basic_functionality_test,
		&callback_test,
		&reset_32bit_master_test,
		&capture_and_compare_test,
	};

	/* Define the test suite */
	DEFINE_TEST_SUITE(tc_suite, tc_tests,
			"SAM TC driver test suite");

	/* Run all tests in the suite*/
	test_suite_run(&tc_suite);

	tc_reset(&tc_test0_module);
	tc_reset(&tc_test1_module);

	while (true) {
		/* Intentionally left empty */
	}
}
Exemple #28
0
/**
 * \internal
 * \brief Cleanup function for polled mode test.
 *
 * This function disables the external interrupt channel.
 *
 * \param test Current test case.
 */
static void cleanup_extint_polled_mode_test(const struct test_case *test)
{
	eic_conf.detection_criteria = EXTINT_DETECT_NONE;
	extint_chan_set_config(EIC_TEST_CHANNEL, &eic_conf);
}