attachInterrupt()<\/code>. The good news, however, is that pin change interrupts are available to you on all I\/O pins instead. They are not quite as convenient and also a bit more difficult to configure, since you have to deal with the registers of the underlying microcontrollers. But don’t worry, it’s not rocket science, either.<\/p>\r\nI will explain the use of pin change interrupts in detail on the ATmega328P (Arduino UNO, Nano, Pro Mini) and then show on the example of the ATtiny85 that the systematics behind it is very similar on all AVR microcontrollers.<\/p>\r\n\n
These are the topics I will discuss:<\/p>\r\n
\r\n- A look inside the ATmega328P<\/a>
\r\n\r\n- Ports, Pins and PCINT<\/a><\/li>\r\n
- Pin Change Interrupts using the ATmega328P – the relevant registers<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Practical examples for the ATmega328P<\/a>
\r\n\r\n- A single pin change interrupt pin<\/a><\/li>\r\n
- Multiple pin change interrupt pins on different ports<\/a><\/li>\r\n
- Multiple pin change interrupt pins on one port<\/a><\/li>\r\n
- Using an entire port<\/a><\/li>\r\n
- Tracking HIGH-LOW and LOW-HIGH changes<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Pin change interrupts on other AVR microcontrollers<\/a>\r\n
\r\n- Example: ATtiny85<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Pin Change Interrupts on MiniEVB Boards<\/a><\/li>\r\n<\/ul>\r\n\n
A look inside the ATmega328P<\/h2>\n\nPorts, Pins and PCINT<\/h3>\n\n
The I\/O pins of the ATmega328P are arranged in the three ports PORTB, PORTC and PORTD, each comprising up to 8 pins. The pins are named accordingly: PB[7:0], PC[6:0], PD[7:0]. Here the notation “PB[7:0]” means: PB7, PB6, PB5 … PB1, PB0. Each pin has a unique pin change interrupt number, namely PCINT[23:0].<\/em><\/p>\r\n\n![\"Pinout](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2019\/12\/Pinout-Atmega-328P-vs-Arduino-UNO-1024x495.png\")
<\/a>Pinout ATmega328P vs. Arduino Pins (UNO, Nano, Pro Mini)<\/figcaption><\/figure>\n\nPin Change Interrupts using the ATmega328P – the relevant registers<\/h3>\n\n
Only one pin change interrupt is available for each port, but it can be triggered on any individual pin of the port, provided the pin has been set up for this purpose. To enable a pin for change interrupts, set the associated bit in the relevant pin change mask register PCMSK[2:0]. Here is an overview:<\/p>\r\n\n![\"Pin](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/pcmsk_registers-1-1024x244.png\")
<\/a>Pin Change Interrupt Mask Register PCMSK[2:0]<\/figcaption><\/figure>\n\nFurthermore, you have to activate the interrupt itself. This is done by setting the associated Pin Change Enable Bit PCIE[2:0] in the Pin Change Interrupt Control Register PCICR.<\/p>\r\n\n![\"Pin](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/register_pcicr-1024x83.png\")
<\/a>Pin Change Interrupt Control Register PCICR<\/figcaption><\/figure>\n\nPCIE0 is responsible for PORTB, PCIE1 for PORTC and PCIE2 for PORTD.<\/p>\r\n\n
In case of an interrupt, the corresponding flag PCIF[2:0] is set in the Pin Change Interrupt Flag Register PCIFR:<\/p>\r\n\n![\"Pin](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/register_pcifr-1024x89.png\")
<\/a>Pin Change Interrupt Flag Register PCIFR<\/figcaption><\/figure>\n\nPractical examples for the ATmega328P<\/h2>\n\nA single pin change interrupt pin<\/h3>\n\n
In the first example, we set up only a single interrupt pin. We choose Arduino pin 6 (PD6 \/ PCINT22), whose level is to change from HIGH to LOW when the button is pressed. For this purpose, we use the internal pull-up resistor. As a result of pressing the button, the board LED should light up for half a second.<\/p>\r\n\n![\"Pin](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/pcint_D6-1.png\")
<\/a>Pin Change Interrupt at D6<\/figcaption><\/figure>\n\nHere is the example sketch for it:<\/p>\r\n\n
const int ledPin = 13; \/\/ = LED_BUILTIN\r\nconst int interruptPin = 6;\r\nvolatile bool event = false;\r\n \r\nISR (PCINT2_vect){ \/\/ PCINT2_vect: interrupt vector for PORTD\r\n event = true;\r\n}\r\n\r\nvoid setup() {\r\n pinMode(interruptPin, INPUT_PULLUP);\r\n PCICR = (1<<PCIE2); \/\/ enable PCINT[23:16] interrupts\r\n PCMSK2 = (1<<PCINT22); \/\/ D6 = PCINT22\r\n}\r\n \r\nvoid loop() {\r\n if(event){\r\n digitalWrite(ledPin, HIGH);\r\n delay(500);\r\n digitalWrite(ledPin, LOW);\r\n event = false;\r\n }\r\n}<\/pre>\r\n\nExplanation to the sketch:<\/p>\r\n
\r\n- With
PCICR = (1<<PCIE2)<\/code> pin change interrupts at PORTD are allowed.<\/li>\r\nPCMSK2 = (1<<PCINT22)<\/code> enables the pin change interrupt at PD6 (= Arduino pin 6).<\/li>\r\n- We pass the associated interrupt vector
PCINT2_vect<\/code> to the ISR. As most people probably already guessed correctly, PCINT1_vect<\/code> would be the relevant vector for PORTC and PCINT0_vect<\/code> the vector for PORTB.<\/li>\r\n<\/ul>\r\nIn this first, minimalistic example, no distinction is made between level changes from HIGH to LOW and from LOW to HIGH. If you press the button down for longer than 500 milliseconds, the LED will light up again when you release it.<\/p>\r\n
Bouncing is not perceptible with this setting. Since I already went into detail about bouncing and debouncing in my last post<\/a>, I won’t repeat that here.<\/p>\r\nAnd if you still need to catch up on the topic of binary operations (e.g. 1<<PCIE2<\/code>) you could take a look at this article<\/a>.<\/p>\r\n\nMultiple pin change interrupt pins on different ports<\/h3>\n\n
In the next step, we will monitor the level of three pushbuttons. This time we output on the serial monitor when an interrupt was triggered and at which pin it happened. For this, we use three pins from different ports:<\/p>\r\n
\r\n- PB1 = Arduino Pin 9 = PCINT1<\/li>\r\n
- PC2 = Arduino Pin A2 = PCINT10<\/li>\r\n
- PD5 = Arduino Pin 5 = PCINT21<\/li>\r\n<\/ul>\r\n\n
This is the circuit:<\/p>\r\n\n![\"3](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/pcint_test_circuit_3_pcints_3_ports.png\")
<\/a>3 pin change interrupts on 3 ports<\/figcaption><\/figure>\n\nAnd here is the corresponding sketch:<\/p>\r\n\n
\r\nconst int interruptPin_1 = 9; \/\/PB1\r\nconst int interruptPin_2 = A2; \/\/PC2\r\nconst int interruptPin_3 = 5; \/\/PD5\r\nvolatile bool event_1 = false;\r\nvolatile bool event_2 = false;\r\nvolatile bool event_3 = false;\r\n \r\nISR (PCINT0_vect){ \r\n event_1 = true;\r\n}\r\n\r\nISR (PCINT1_vect){ \r\n event_2 = true;\r\n}\r\n\r\nISR (PCINT2_vect){ \r\n event_3 = true;\r\n}\r\n\r\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n pinMode(interruptPin_1, INPUT_PULLUP);\r\n pinMode(interruptPin_2, INPUT_PULLUP);\r\n pinMode(interruptPin_3, INPUT_PULLUP);\r\n PCICR = (1<<PCIE2) | (1<<PCIE1) | (1<<PCIE0);\r\n PCMSK0 = (1<<PCINT1);\r\n PCMSK1 = (1<<PCINT10);\r\n PCMSK2 = (1<<PCINT21); \r\n}\r\n \r\nvoid loop() {\r\n if(event_1){\r\n Serial.println(\"Interrupt at pin 9\");\r\n delay(300); \r\n event_1 = false;\r\n }\r\n if(event_2){\r\n Serial.println(\"Interrupt at pin A2\");\r\n delay(300);\r\n event_2 = false;\r\n }\r\n if(event_3){\r\n Serial.println(\"Interrupt at pin 5\");\r\n delay(300);\r\n event_3 = false;\r\n } \r\n}<\/pre>\r\n <\/p>\r\n<\/div>\r\n\n
Explanations to three_pcint_interrupts_at_three_ports.ino<\/h4>\n\n\r\n- With
PCICR = (1<<PCIE2) | (1<<PCIE1) | (1<<PCIE0);<\/code> interrupts are allowed at PORTB, PORTC and PORTD.<\/li>\r\n- The three pins are set up as interrupt pins in their associated PCMSK[2:0] register.<\/li>\r\n
- For each pin change interrupt pin, we have a separate ISR.<\/li>\r\n
- The 300-millisecond delays conceal the bouncing and the additional interrupt when the button is released.<\/li>\r\n<\/ul>\r\n\n
Multiple pin change interrupt pins on one port<\/h3>\n\n
In the next example we use pin change interrupts for three pushbuttons connected to pins 5, 6 and 7, i.e. PCINT21, PCINT22 and PCINT23. Now we have to consider that all three pins belong to PORTD and therefore only one interrupt is available. But since we know the levels of the pins in the ground state, we simply check in the ISR which pin is deviating using digitalRead()<\/code> and thus is “the culprit”.<\/p>\r\nTo add a little variety, we pull pin 5 and pin 7 to LOW with pull-down resistors. Pin 6 uses the internal pull-up resistor.<\/p>\r\n\n![\"3](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/pcint_test_circuit_3_pcints_one_port.png\")
<\/a>3 pin change interrupt pins on one port<\/figcaption><\/figure>\n\nPlease note, that the connections located on the top left and bottom left or top right and bottom right of the pushbuttons are connected permanently.<\/p>\r\n
This is the sketch:<\/p>\r\n\n
\r\nconst int interruptPin_1 = 5;\r\nconst int interruptPin_2 = 6;\r\nconst int interruptPin_3 = 7;\r\nvolatile bool event_1 = false;\r\nvolatile bool event_2 = false;\r\nvolatile bool event_3 = false;\r\n \r\nISR (PCINT2_vect){ \r\n if(digitalRead(interruptPin_1)){\r\n event_1 = true;\r\n }\r\n else if(!digitalRead(interruptPin_2)){\r\n event_2 = true;\r\n }\r\n else if(digitalRead(interruptPin_3)){\r\n event_3 = true;\r\n }\r\n}\r\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n pinMode(interruptPin_1, INPUT);\r\n pinMode(interruptPin_2, INPUT_PULLUP);\r\n pinMode(interruptPin_3, INPUT);\r\n PCICR = (1<<PCIE2);\r\n PCMSK2 = (1<<PCINT23)|(1<<PCINT22)|(1<<PCINT21); \r\n}\r\n \r\nvoid loop() {\r\n if(event_1){\r\n Serial.println(\"Interrupt at pin 5\");\r\n delay(300); \r\n event_1 = false;\r\n }\r\n if(event_2){\r\n Serial.println(\"Interrupt at pin 6\");\r\n delay(300);\r\n event_2 = false;\r\n }\r\n if(event_3){\r\n Serial.println(\"Interrupt at pin 7\");\r\n delay(300);\r\n event_3 = false;\r\n } \r\n}<\/pre>\r\n <\/p>\r\n<\/div>\r\n\n
By checking the pin level using digitalRead()<\/code>, the interrupts triggered by releasing the pushbuttons are ignored (unless the pushbutton jumps when released). This may be desirable – or not. In the next but one example, I will come back to how you can detect pin changes in both directions when using one port.<\/p>\r\n\nUsing an entire port <\/h3>\n\n
Now we will use (almost) the entire PORTD. This includes Arduino pins 0 to 7. Pins 0 and 1 are not suitable for pin change interrupts because they are RX and TX. We therefore restrict the interrupts to pins 2 to 7 or PD[7:2].<\/p>\r\n
The following circuit is used for this purpose:<\/p>\r\n
\n![\"Pin](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/pcint_test_circuit.png\")
<\/a>Pin Change Interrupt Test Circuit<\/figcaption><\/figure>\n<\/div>\nI have added pull-down resistors to pins 3, 5, and 7, and pins 2, 4, and 6 are pulled HIGH with their internal pull-up resistors. If you just want to evaluate buttons, then it would be much easier to pull all pins to the same level. However, the buttons used here are only meant to be representative of any<\/em> interrupt triggers, and this could be a mixture of LOW-active and HIGH-active ones.<\/p>\r\n\nWith six pins, it would be a bit unwieldy to query all pin states in case of an interrupt with digitalRead()<\/code> and to use individual flags event_[1:6]<\/code>. This can be solved in a smarter way – like this, for example:<\/p>\r\n\n\r\nint interruptPin[6] = {2,3,4,5,6,7};\r\nvolatile bool event = false;\r\nvolatile byte changedPin = 0;\r\nvolatile unsigned long lastInterrupt = 0;\r\nconst byte interruptPinMask = 0b11111100;\r\nconst byte intPinPolarityMask = 0b01010100;\r\n \r\nISR (PCINT2_vect){ \r\n if(millis()-lastInterrupt > 300){\r\n byte interruptPinsStatus = PIND & interruptPinMask;\r\n interruptPinsStatus ^= intPinPolarityMask;\r\n if(interruptPinsStatus){\r\n changedPin = log(interruptPinsStatus)\/log(2); \/\/ short, but slow! Alternative below:\r\n\/\/ changedPin = 0;\r\n\/\/ while(!(interruptPinsStatus & 1)){\r\n\/\/ changedPin++;\r\n\/\/ interruptPinsStatus = (interruptPinsStatus >> 1);\r\n\/\/ }\r\n event = true;\r\n }\r\n lastInterrupt = millis();\r\n }\r\n}\r\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n \r\n pinMode(interruptPin[0], INPUT_PULLUP);\r\n pinMode(interruptPin[1], INPUT);\r\n pinMode(interruptPin[2], INPUT_PULLUP);\r\n pinMode(interruptPin[3], INPUT);\r\n pinMode(interruptPin[4], INPUT_PULLUP);\r\n pinMode(interruptPin[5], INPUT);\r\n \r\n PCICR = (1<<PCIE2);\r\n PCMSK2 = interruptPinMask; \r\n}\r\n \r\nvoid loop() {\r\n if(event){\r\n Serial.print(\"Interrupt at pin \");\r\n Serial.println(changedPin);\r\n event = false;\r\n }\r\n}<\/pre>\r\n <\/p>\r\n<\/div>\r\n\n
Explanation of pcint_interrupt_generalized.ino<\/h4>\n\n\r\n- The interrupt pins are defined as an array.<\/li>\r\n
- The
interruptPinMask<\/code> indicates which PORTD pins serve as interrupt pins (“1”) and which are ignored (“0”).<\/li>\r\nintPinPolarityMask<\/code> contains the default level of the PORTD pins (button not pressed).<\/li>\r\n- In case of an interrupt, the current level of the pins is determined with PIND. This replaces all queries using
digitalRead()<\/code>.\r\n\r\n- By
PIND & interruptPinMask<\/code> we ignore the state of pins 0 and 1.<\/li>\r\n- By
interruptPinsStatus ^= intPinPolarityMask<\/code> we find out which pin deviates from the default state. The logical operator “^” (XOR, exclusive OR) returns 1 if exactly<\/em> one of the operands is 1.\r\n\r\n- For example, if the interrupt was triggered at PD4 (4),
interruptPinsStatus<\/code> would be 0b00010000 after the bit operations.<\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\n<\/li>\r\n- The condition
if(interruptPinsStatus){...<\/code> catches cases where no triggering interrupt pin can be determined.<\/li>\r\n<\/ul>\r\nIn the case of PORTD, the fact that PDx<\/em> corresponds to Arduino pin x<\/em> helps us. To find x<\/em> (changedPin<\/code>), we need to find where the 1 is located in interruptPinsStatus<\/code>. There are several ways to do this:<\/p>\r\n\r\n- x = log2<\/sub>(interruptPinsMask). But since no logarithm to base 2 is available as a function, we apply the logarithm rule: log2<\/sub>(x) = log10<\/sub>(x)\/log10<\/sub>(2). This is a nice, short code, but calculating a logarithm is computationally intensive and therefore correspondingly slow. I have determined a good hundred microseconds for this calculation.<\/li>\r\n
- You move
interruptPinsStatus<\/code> to the right until its value is 1 (see commented out code).<\/li>\r\n- You divide
interruptPinsStatus<\/code> by 2 until the remainder is 1.<\/li>\r\n<\/ul>\r\nOtherwise, of course, you can also use switch...case<\/code> structures.<\/p>\r\n\nTracking HIGH-LOW and LOW-HIGH changes<\/h3>\n\n
In the last two sketches, we only considered level changes in one direction, i.e. deviations from the default state. To evaluate changes in both directions, we introduce the variable lastInterruptsPinStatus<\/code>, in which we store the status of PIND (after adjusting for the ignored pins 0 and 1) at the respective time of the last interrupt. On a new interrupt, we compare the new state (currentInterruptPinsStatus<\/code>) with the previous one (instead of intPinPolarityMask<\/code>).<\/p>\r\nWhether a HIGH-LOW or LOW-HIGH change has taken place can be recognized by whether the new status value is smaller or larger.<\/p>\r\n
Here is the sketch:<\/p>\r\n\n
\r\nint interruptPin[6] = {2,3,4,5,6,7};\r\nvolatile bool event = false;\r\nvolatile byte changedPin = 0;\r\nconst byte interruptPinMask = 0b11111100;\r\nvolatile byte lastInterruptPinsStatus = 0b01010100;\r\nvolatile bool risingEdge = false; \r\n \r\nISR (PCINT2_vect){ \r\n byte currentInterruptPinsStatus = PIND & interruptPinMask;\r\n \r\n if(currentInterruptPinsStatus > lastInterruptPinsStatus){\r\n risingEdge = true;\r\n }\r\n else{\r\n risingEdge = false;\r\n }\r\n \r\n byte statusCopy = currentInterruptPinsStatus;\r\n currentInterruptPinsStatus ^= lastInterruptPinsStatus;\r\n lastInterruptPinsStatus = statusCopy;\r\n \r\n if(currentInterruptPinsStatus){\r\n changedPin = 0;\r\n while(!(currentInterruptPinsStatus & 1)){\r\n changedPin++;\r\n currentInterruptPinsStatus = (currentInterruptPinsStatus >> 1);\r\n }\r\n event = true;\r\n }\r\n}\r\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n \r\n pinMode(interruptPin[0], INPUT_PULLUP);\r\n pinMode(interruptPin[1], INPUT);\r\n pinMode(interruptPin[2], INPUT_PULLUP);\r\n pinMode(interruptPin[3], INPUT);\r\n pinMode(interruptPin[4], INPUT_PULLUP);\r\n pinMode(interruptPin[5], INPUT);\r\n \r\n PCICR = (1<<PCIE2);\r\n PCMSK2 = interruptPinMask; \r\n}\r\n \r\nvoid loop() {\r\n if(event){\r\n Serial.print(\"Interrupt at pin \");\r\n Serial.println(changedPin);\r\n Serial.print(\"Pin went: \");\r\n if(risingEdge){\r\n Serial.println(\"HIGH\");\r\n }\r\n else{\r\n Serial.println(\"LOW\");\r\n }\r\n event = false;\r\n }\r\n}<\/pre>\r\n <\/p>\r\n<\/div>\r\n\n
If you try the sketch, you’ll probably notice that I removed the debouncing. It doesn’t fit well with this concept, as status changes triggered by bouncing fall under the radar. On the other hand, the sketch in this form does not work well with bouncing pushbuttons, since new interrupts can occur during output to the serial monitor (Serial.print()<\/code> is quite slow). However, the Sketch works reliably with hardware-debounced pushbuttons (see last post<\/a>) or other interrupt sources that do not trigger too quickly one after the other.<\/p>\r\n\nPin change interrupts on other AVR microcontrollers <\/h2>\n\n
Since we are accessing the microcontroller’s registers directly, the code for pin change interrupts is specific to the microcontroller. However, the “translation” of the code for other AVR microcontrollers is not particularly difficult. Take a look at the data sheet and search for chapter External Interrupts, subitem: Pin Change Interrupts.<\/p>\r\n\n
Example: ATtiny85<\/h3>\n\n
We try this for the ATtiny85, which is used e.g. on the Digispark board. It has only one pin change interrupt, which you enable by setting the Pin Change Enable Bit PCIE in the Global Interrupt Mask Register GIMSK:<\/p>\r\n\n![\"Global](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/register_gimsk-1024x95.png\")
<\/a>Global Interrupts Mask Register GIMSK<\/figcaption><\/figure>\n\nYou activate the pins for change interrupts in the Pin Change Mask Register PCMSK.<\/p>\r\n\n![\"Pin](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/09\/register_pcmsk-1024x91.png\")
Pin Change Interrupt Mask Register PCMSK<\/figcaption><\/figure>\n\nA sketch could then look like this:<\/p>\r\n\n
const int ledPin = 4;\r\nconst int interruptPin = 3;\r\nvolatile bool event = false;\r\n \r\nISR (PCINT0_vect){\r\n event = true;\r\n}\r\n\r\nvoid setup() {\r\n pinMode(ledPin, OUTPUT);\r\n pinMode(interruptPin, INPUT_PULLUP);\r\n GIMSK |= (1<<PCIE); \/\/ General Interrupt Mask Register\r\n PCMSK = (1<<PCINT3); \/\/ 3 = PCINT3\r\n}\r\n \r\nvoid loop() {\r\n if(event){\r\n digitalWrite(ledPin, HIGH);\r\n delay(500);\r\n digitalWrite(ledPin, LOW);\r\n event = false;\r\n }\r\n}<\/pre>\r\n\nPin Change Interrupts on MiniEVB Boards<\/h2>\n\n
The MiniEVB boards<\/a> based on the LGT8F328P show a high compatibility with the ATmega328P. Porting sketches for ATmega328P based Arduinos to the LQFP32-MiniEVB <\/a>board is especially easy. You can adopt the sketches 1:1. For the LQFP48-based MiniEVB boards only some pins are available, whereas for the SSOP20-based representatives some pins are not available. Apart from that, it’s all the same.<\/p>\r\n\nOutlook<\/h2>\n\n