Published September 25, 2021

Multiple Switches, One Interrupt

Use a single interrupt to easily and simply process any number of switches, button or toggle and wired in any scheme.

IntermediateFull instructions provided2,192

Things used in this project

Hardware components

Arduino UNO

Or any Arduino microcontroller

Toggle Switch, Toggle

Example uses three toggle switches, but this is configurable

Resistor 10k ohm

Example uses three switches wired for 10k ohm pull down

Jumper wires (generic)

See wiring diagram

Tactile Switch, Top Actuated

Example uses three button switches, but this is configurable

Solderless Breadboard Half Size

Software apps and online services

Arduino IDE

Story

Background and Origins

In this article I present a method for configuring any number of switches linked to a single (common) interrupt service routine (ISR). The method is fully software driven and does not rely on any physical wiring of switches to interrupt pins.

The article originates from previous work in developing a library to efficiently handle switches of any type and wired in differing schemes - the ez_switch_lib.

The ez_switch_lib offers some interesting and unique features, in summary:

any switch type may be configured, eg button, toggle, etc

common switch wiring schemes are supported

multiple switches of different types and wiring schemes can be configured concurrently

switch debounce is automatically taken care of and this can also be user configured

the status of switches may be tested at any time, eg testing if a switch is in transition, on or off, etc

switches may be automatically linked to other digital output pins so that when switching occurs the linked output pin is also triggered (set or cleared)

It is the latter feature, linking switches to other digital output pins, that this article highlights and on which it is based.

Linking Switches to Interrupts

This article shows how we are able to link (associate) any number of switches, of any type and wired in different schemes, to interrupts with very little effort or any additional wiring - there are no wires connecting the switches to interrupts!

To keep the example simple, we will use a single ISR to handle all switches, but this is variable - similarly, we can use any number of ISRs and external interrupt pins as we wish (up to the microcontroller design limits, of course).

So, how do we accomplish this?

As alluded to above, the ez_switch_lib library provides a particular feature that allows a switch to be linked to a digital output pin such that when the switch is actuated the associated output pin is automatically set/cleared. This function is called link_switch_to_output and has just three parameters:

The id of the switch to which the digital output pin is to be linked

the pin number of the digital output pin to be linked

the initial setting for the linked output pin (i.e. LOW or HIGH)

Once a switch is declared/defined it may then be associated with a digital output pin using the above function. This is the essence of the method - all we then need to do is to define an ISR using the attachInterrupt function to handle the switch event on any suitable external interrupt digital pin.

We will see how we are able to declare a number of switches, of different types and wired in different ways, but such that each automatically triggers a defined and common ISR when actuated. What this ISR does to process switches is not within scope of this article, but the reader will see where the various 'hooks' exist in the ISR and sketch to add specific end user code to process each possible switch interrupt event type.

Let's look at the example sketch and the switches it is configured for.

The example sketch will use seven digital pins, six for switches and one for the common interrupt pin, assigned and wired as per the table below:

Switch Configurations

(Wire up the components as per table above and the Schematics, below, using the breadboard.)

To note is:

we use digital pin 2 as the common pin assigned to the ISR, observe that this pin has nothing physically connected to it

'circuit_C1' and 'circuit_C2' are reserved words in the ez_switch_lib library and each represents a circuit with an external 10k ohm pull down resistor and a basic circuit (no additional components other than the switch itself), respectively

we assign digital pins 3-8 to switches as follows:

3 x toggle switches wired with a pulldown 10k ohm resistor - 'circuit_C1' (see Schematics below)

3 x button switches wired directly, 'circuit_C2' (see Schematics below)

all switches are software linked to a common digital pin 2 (ISR pin) using the link_switch_to_output function after each switch is created (add_switch function)

The above switch configuration is arbitrary and used to demonstrate the flexibility of the ez_switch_lib library and switches may be linked to a single ISR, but any combination switch types, switch circuit wiring and multiple ISRs may be used.

Sketch Design

The sketch has six principal parts:

ez_switch_lib declaration - the declaration of the ez_switch_lib library (i.e. #include "ez_switch_lib.h"). To run the sketch you will need copy over the ez_switch_lib library files (.cpp,.h and.txt) to the Arduino libraries directory into a directory named 'ez_switch_lib', ie../Arduino/libraries/ez_switch_lib (see the ez_switch_lib article to access and download these).

create ez_switch_lib instance - creates and establishes the ez_switch_lib library instance of size equal to the number of switches we wish to configure (here six). The sketch assigns the name 'my_switches' for the instance which we use to prefix all of our ez_switch_lib functions and resources, eg 'my_switches.add_switch(..)', etc.

define switch configuration data - data defining our switch configurations. At the heart of the sketch lies the switch configuration data which is held in a two dimensional array called 'my_switch_data' with each row defining the data associated with each switch, as follows:

column[0] - represents the switch type ('button_switch' or ' toggle_switch'). (Again, 'button_switch' or ' toggle_switch' are ez_switch_lib library reserved words and define the switch type being considered.)

column[1] - this is the digital pin assigned to the switch

column[2] - represents the switch wiring scheme ( reserved words 'circuit_C1' or 'circuit_C2')

the setup function - you will notice that this is where we declare each of our switches to the library using the add_switch function and also assign the common interrupt pin to each switch (the link_switch_to_output function).

main loop processing. On examination the main loop does not appear to do much at all - it simply continuously polls each switch in turn using the read_switch function, looking for state changes. This is because the method is fully software driven and therefore needs to continually look for state changes. When a state change occurs, two things happen:

1. the switch's associated linked output pin (the common interrupt pin) is automatically raised high (RISING), thus triggering the ISR which will then process the switch event for the actuating switch, and

2. following the completion of ISR processing, the read_switch function will return a value of 'switched' (a reserved ez_switch_lib library word also) which can then be further processed in the main loop, if required - two bites of the same cherry!.

an interrupt service routine (ISR) - a fairly simple ISR, designed to recognise the different switch types and their associated characteristics using the ez_switch_lib available variables. You will note that the ISR does nothing more than report to the serial monitor which switch event has been triggered. In ordinary circumstances the use of serial print I/O is not to be recommended, it is used here just to provide visual confirmation that the sketch is doing what it should be doing. Add your own end user code at each of the 'hooks' as appropriate to your project's needs.

Okay, how does it work?

The ez_switch_lib removes from our considerations any concerns about switch bounce or how switches are wired. It can also provides us with very useful status information about our switches, for example, switch type, if a switch is transitioning or transitioned or otherwise, whether a toggle switch is presently on or off, etc. But, most significantly, it provides us with the ability to automatically link switches to another digital output pin that we can use to trigger an ISR when the associated switch is actuated.

Now, in our example sketch, each declared switch triggers the same ISR, so the question is how can the ISR determine which switch has actuated, i.e. which switch triggered the ISR? Again, the ez_switch_lib caters for this. It provides the switch id of the last switch that actuates. It is this feature that provides the ISR with the means to process the correct switch. The specific library variable is called 'last_switched_id'.

With this knowledge the ISR can process the specific requirements for the actuated switch.

All good? Yes, providing you recognise that button and toggle style switches each have their own characteristics which the ISR must also cater for. Specifically:

button style switches - an actuation cycle goes from off-on and back to off before it can be said to have been fully switched.

toggle style switches - toggle switches have two actuation cycles - they can transition from off-on or from on-off.

Again, the ez_switch_lib allows for these specific switch characteristics, giving the end user (and the ISR) the means to process each event type appropriately.

When you examine the ISR code, you will see how it handles the above scenarios specifically and simply.

Also, let's not forget that whilst the ISR will process switch actuations, there is an additional point at which further processing may be applied. If you examine the main loop you will see that each switch is polled and read directly and constantly. It is this polling of the switches that allows the triggering of the switches' ISR. However, every time a switch ISR is triggered the switch itself will also be deemed to have been actuated ('switched'). The answer from the read_switch function in the polling loop will be given as 'switched' if the switch has been actuated. It therefore provides an additional opportunity to add further switch processing in the main polling loop should this be needed, or if the switch does not have a linked ISR output pin.

Who says we cant have our cake and eat it?!!

Finally

I hope you have found this article of some interest and worth considering for your own projects. I do recommend that you explore more fully the ez_switch_lib article and download its User Guide and Crib Sheet for a full appreciation of capabilities.

Code

Sketch With Many Switches Serviced By A Single Interrupt Service Routine (ISR)

// Ron Bentley, Stafford UK
// September 2021
//
// This example and code is in the public domain and may be used without
// restriction and without warranty.
//
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//         Example sketch - Multiple switches handled by a single interrupt
//         '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
// This sketch demonstrates how the ez_switch_lib may be used to handle multiple
// switches (button & toggle switches in this example)with a single interrupt routine.
//
// The use of the ez_switch_lib library for switches provides:
//   * switch type independence
//   * switch circuit type independence
//   * automatic multiple switch debounce handling
//   * parallel switching capabilities, and
//   * automatic interrupt handling for all switches
//
// The sketch will use digital pin 2 as the common interrupt pin and
// pins 3, 4, 5, 6, 7 and 8 as the switch pins.
//
// For an understanding of the full capabilities of the 'ez_switch_lib' library see
// the USER GUIDE:
// https://github.com/ronbentley1/ez_switch_lib-Arduino-Library/blob/main/ez_switch_lib_user_guide%2C%20v1.04.pdf
//
// or a synopsis CRIB SHEET:
// https://github.com/ronbentley1/ez_switch_lib-Arduino-Library/blob/main/ez_switch_lib%20crib%20sheet.pdf
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

#include <ez_switch_lib.h>          // declare the switch library

#define common_interrupt_pin    2   // external (common) interrupt pin that all declared switches will use

#define num_switches            6   // number of switches the sketch will declare & use

Switches my_switches(num_switches); // create the 'Switches' instance for the given number of switches

// Declare the data required for each of our switches, 'my_switch_data':
// 'my_switch_data' layout, one row of data for each switch to be configured,
// as follows:
// [][0] = switch type (button_switch or toggle_switch)
// [][1] = digital pin connected to switch
// [][2] = the circuit type connecting the switch, here the first 3 switches
//         will have 10k ohm pull down resistors wired (circuit_C1 - INPUT type)
//         and the remainder none (circuit_C2 - INPUT_PULLUP type).
byte my_switch_data[][3] =
{
  toggle_switch,  3, circuit_C1, // this will be the switch entry for switch_id 0
  toggle_switch,  4, circuit_C1, // this will be the switch entry for switch_id 1
  toggle_switch,  5, circuit_C1, // etc
  button_switch,  6, circuit_C2,
  button_switch,  7, circuit_C2,
  button_switch,  8, circuit_C2,
};

void setup() {
  int result;
  Serial.begin(115200);
  // Add all switches to the library switch control structure we defined above
  // and link all switches to the same interrupt pin as a linked output
  for (uint8_t switch_id = 0; switch_id < num_switches; switch_id++) {
    result = my_switches.add_switch(
               my_switch_data[switch_id][0],  // switch type
               my_switch_data[switch_id][1],  // digital pin switch is wired to
               my_switch_data[switch_id][2]); // type of circuit switch is wired as
    // Check that we have successfully added the current switch or not
    if (result < 0) {
      // No slots left or bad parameters
      Serial.println("*** Failure to add switch.\n Terminated");
      Serial.flush();
      exit(0);
    }
    // now make the linkage for this switch_id to the common interrupt pin
    result = my_switches.link_switch_to_output(
               switch_id,             // switch to be linked
               common_interrupt_pin,  // digital pin to link to for interrupt
               LOW);                  // start with interrupt pin LOW, as interrupt will be triggered on RISING
    // Check that we have successfully linked the current switch or not
    if (result < 0) {
      // Could not link the given switch
      Serial.println("*** Failure to link switch.\n Terminated");
      Serial.flush();
      exit(0);
    }
  }
  // set debounce period
  my_switches.set_debounce(150);  // can be reduced if you have good quality switches
  // Now establish the common interrupt service routine (ISR) that
  // will be used for all declared switches.
  attachInterrupt(
    digitalPinToInterrupt(common_interrupt_pin),
    switch_ISR, // name of the sketch's ISR handler for switch interrupts
    RISING);    // trigger on a rising pin value
} // end of setup function

void loop() {
  // Keep testing switches, and let the interrupt handler do its thing
  // once a switch is switched to 'on'
  // We use 'read_switch' function as this deals with both switch types for us transparently.
  for (uint8_t switch_id = 0; switch_id < num_switches; switch_id++) {
    if (my_switches.read_switch(switch_id) == switched) {
      // *** Add any code here, if any, to process this switch as it has been actuated.
      // *** This is in addition to whatever the ISR does following the triggering
      // *** of the interrupt, if this switch has been linked to the common interrupt pin.

    }
  }
}

// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Common ISR for handling interrupt triggers arising from associated switches
// when they transition to on then off for button switches and on or off
// for toggle switches.  The routine knows which switch has generated
// the interrupt because the ez_switch_lib switch read function records the
// actuated switch in the library variable 'last_switched_id'.
//
// The routine does nothing more than demonstrate the effectiveness of the
// use of a single ISR handling multiple switches by using the serial monitor
// to confirm correct operation.
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void switch_ISR()
{
  // Reset the interrupt pin to LOW, so that any other switch will fire the
  // interrupt whist one or more switches complete their transition stage
  byte switch_id = my_switches.last_switched_id;  // switch id of switch currently switched
  digitalWrite(my_switches.switches[switch_id].switch_out_pin, LOW);
  // Reset the soft status of the switch setting to ensure that we get an interrupt event
  // on the linked interrupt pin at next switch change
  my_switches.switches[switch_id].switch_out_pin_status = LOW;
  Serial.print("** Interrupt triggered for switch id: ");
  Serial.print(switch_id); // the id of the last triggering switch
  if (my_switches.switches[switch_id].switch_type == button_switch) {
    // this was a button switch triggering the interrupt
    // *** Button switch processing
    // *** Put end user code here to deal with this event

    Serial.println(".. button switch..switched");
  } else {
    // this was a toggle switch triggering the interrupt
    // determine if the switch transitioned to 'on' or 'off'
    // and process accordingly
    Serial.print(".. toggle switch.. ");
    if (my_switches.switches[switch_id].switch_status == on) {
      // *** Toggle switch processing for switch being 'on'
      // *** Put end user code here to deal with this event

      Serial.println("is on");
    } else {
      // *** Toggle switch processing for switch being 'off'
      // *** Put end user code here to deal with this event

      Serial.println("is off");
    }
  }
  Serial.flush();
} // end of switch_ISR

Credits

ronbentley1

25 projects • 13 followers

Multiple Switches, One Interrupt

Things used in this project

Hardware components

Software apps and online services

Story

Background and Origins

Linking Switches to Interrupts

Sketch Design

Finally

Schematics

Multiple Switches, One ISR

Code

Sketch With Many Switches Serviced By A Single Interrupt Service Routine (ISR)

Credits

ronbentley1

Comments

Embed the widget on your own site

Multiple Switches, One Interrupt

Multiple Switches, One Interrupt

Things used in this project

Hardware components

Software apps and online services

Story

Background and Origins

Linking Switches to Interrupts

Sketch Design

Finally

Schematics

Multiple Switches, One ISR

Code

Sketch With Many Switches Serviced By A Single Interrupt Service Routine (ISR)

Credits

ronbentley1

Comments

Related channels and tags