InterruptIn

Use the InterruptIn interface to trigger an event when a digital input pin changes.

API

 
 /* mbed Microcontroller Library
  * Copyright (c) 2006-2013 ARM Limited
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #ifndef MBED_INTERRUPTIN_H
 #define MBED_INTERRUPTIN_H
 
 #include "platform/platform.h"
 
 #if defined (DEVICE_INTERRUPTIN) || defined(DOXYGEN_ONLY)
 
 #include "hal/gpio_api.h"
 #include "hal/gpio_irq_api.h"
 #include "platform/Callback.h"
 #include "platform/mbed_critical.h"
 #include "platform/mbed_toolchain.h"
 
 namespace mbed {
 /** \addtogroup drivers */
 
 /** A digital interrupt input, used to call a function on a rising or falling edge
  *
  * @note Synchronization level: Interrupt safe
  *
  * Example:
  * @code
  * // Flash an LED while waiting for events
  *
  * #include "mbed.h"
  *
  * InterruptIn event(p16);
  * DigitalOut led(LED1);
  *
  * void trigger() {
  * printf("triggered!\n");
  * }
  *
  * int main() {
  * event.rise(&trigger);
  * while(1) {
  * led = !led;
  * wait(0.25);
  * }
  * }
  * @endcode
  * @ingroup drivers
  */
 class InterruptIn {
 
 public:
 
  /** Create an InterruptIn connected to the specified pin
  *
  * @param pin InterruptIn pin to connect to
  */
  InterruptIn(PinName pin);
  virtual ~InterruptIn();
 
  /** Read the input, represented as 0 or 1 (int)
  *
  * @returns
  * An integer representing the state of the input pin,
  * 0 for logical 0, 1 for logical 1
  */
  int read();
 
  /** An operator shorthand for read()
  */
  operator int();
 
 
  /** Attach a function to call when a rising edge occurs on the input
  *
  * @param func A pointer to a void function, or 0 to set as none
  */
  void rise(Callback<void()> func);
 
  /** Attach a member function to call when a rising edge occurs on the input
  *
  * @param obj pointer to the object to call the member function on
  * @param method pointer to the member function to be called
  * @deprecated
  * The rise function does not support cv-qualifiers. Replaced by
  * rise(callback(obj, method)).
  */
  template<typename T, typename M>
  MBED_DEPRECATED_SINCE("mbed-os-5.1",
  "The rise function does not support cv-qualifiers. Replaced by "
  "rise(callback(obj, method)).")
  void rise(T *obj, M method) {
  rise(callback(obj, method));
  }
 
  /** Attach a function to call when a falling edge occurs on the input
  *
  * @param func A pointer to a void function, or 0 to set as none
  */
  void fall(Callback<void()> func);
 
  /** Attach a member function to call when a falling edge occurs on the input
  *
  * @param obj pointer to the object to call the member function on
  * @param method pointer to the member function to be called
  * @deprecated
  * The rise function does not support cv-qualifiers. Replaced by
  * rise(callback(obj, method)).
  */
  template<typename T, typename M>
  MBED_DEPRECATED_SINCE("mbed-os-5.1",
  "The fall function does not support cv-qualifiers. Replaced by "
  "fall(callback(obj, method)).")
  void fall(T *obj, M method) {
  fall(callback(obj, method));
  }
 
  /** Set the input pin mode
  *
  * @param pull PullUp, PullDown, PullNone
  */
  void mode(PinMode pull);
 
  /** Enable IRQ. This method depends on hw implementation, might enable one
  * port interrupts. For further information, check gpio_irq_enable().
  */
  void enable_irq();
 
  /** Disable IRQ. This method depends on hw implementation, might disable one
  * port interrupts. For further information, check gpio_irq_disable().
  */
  void disable_irq();
 
  static void _irq_handler(uint32_t id, gpio_irq_event event);
 
 protected:
  gpio_t gpio;
  gpio_irq_t gpio_irq;
 
 };
 
 } // namespace mbed
 
 #endif
 
 #endif
MBED_WEAK void core_util_critical_section_enter(void)
Definition: mbed_critical.c:56
#define MBED_DEPRECATED_SINCE(D, M)
Definition: mbed_toolchain.h:245
void rise(Callback< void()> func)
Definition: InterruptIn.h:59
void fall(Callback< void()> func)
Callback< R()> callback(R(*func)()=0)
Definition: Callback.h:3536
void mode(PinMode pull)
Definition: Callback.h:35
InterruptIn(PinName pin)
Definition: AnalogIn.h:27
MBED_WEAK void core_util_critical_section_exit(void)
Definition: mbed_critical.c:81

Warnings:

  • No blocking code in ISR: avoid any call to wait, infinite while loop or blocking calls in general.

  • No printf, malloc or new in ISR: avoid any call to bulky library functions. In particular, certain library functions (such as printf, malloc and new) are non re-entrant, and their behavior could be corrupted when called from an ISR.

Hello World!

 


/* mbed Example Program
 * Copyright (c) 2006-2014 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "mbed.h"
 
InterruptIn button(SW2);
DigitalOut led(LED1);
DigitalOut flash(LED4);
 
void flip() {
    led = !led;
}
 
int main() {
    button.rise(&flip);  // attach the address of the flip function to the rising edge
    while(1) {           // wait around, interrupts will interrupt this!
        flash = !flash;
        wait(0.25);
    }
}

Example

Try the following example to count rising edges on a pin.

 


#include "mbed.h"

class Counter {
public:
    Counter(PinName pin) : _interrupt(pin) {        // create the InterruptIn on the pin specified to Counter
        _interrupt.rise(callback(this, &Counter::increment)); // attach increment function of this counter instance
    }

    void increment() {
        _count++;
    }

    int read() {
        return _count;
    }

private:
    InterruptIn _interrupt;
    volatile int _count;
};

Counter counter(SW2);

int main() {
    while(1) {
        printf("Count so far: %d\n", counter.read());
        wait(2);
    }
}

To read an input, see DigitalIn.

For timer-based interrupts, see Ticker (repeating interrupt) and Timeout (one-time interrupt).