Thank you for your work on this library!

I'm using ATMEGA328P chip. Here is my setup function:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);
  while(!Serial);
  Serial.setTimeout(1000);

  pinMode(PIN_COUNTER_1, INPUT_PULLUP);
  digitalWrite(LED_BUILTIN, HIGH);
  enableInterrupt(PIN_COUNTER_1, c1_fall, FALLING);
  enableInterrupt(PIN_COUNTER_1, c1_rise, RISING);
}

Within c1_rise function, the c1_rstatus variable is incremented successfully.

Within c1_fall function, the c1_fstatus variable is never incremented.

I can't figure out what I'm doing wrong with the library.

Here's my full ino script:

#include <EnableInterrupt.h>

#define PIN_COUNTER_1 9
#define DEBOUNCE 10
#define COOLOFF 1000
#define DELAY_PRINT 50

volatile unsigned long c1 = 0;
volatile unsigned long last_c1 = 0;
volatile unsigned long c1_ftime = 0;
volatile unsigned long c1_rtime = 0;

volatile unsigned long c1_fstatus = 0;
volatile unsigned long c1_rstatus = 0;

unsigned int t = 0;
unsigned int last_t = 0;

void output() {
  if(t - last_t < DELAY_PRINT) {
    return;
  }

  if(c1 == last_c1) {
    return;
  }
  
  Serial.print("C1\t");
  Serial.println(c1);
  Serial.print("ftime, rtime: ");
  Serial.print(c1_ftime);
  Serial.print(", ");
  Serial.println(c1_rtime);
  Serial.print(c1_fstatus);
  Serial.print(", ");
  Serial.println(c1_rstatus);
  last_c1 = c1;
  last_t = t;
}

// Only register a falling edge if it's long enough away from the previous rising edge (debounce)
void c1_fall() {
  unsigned long itime = millis();

  c1_fstatus = 1;

  // If a falling edge has been registered
  // and the time since last falling edge is less than debounce time,
  // ignore!
  if(c1_ftime > 0
  && itime - c1_ftime < DEBOUNCE) {
    return;
  }

  c1_fstatus = 2;

  // If a rising edge has been registered
  // and the time since last rising edge is less than cooloff time,
  // ignore!
  if(c1_rtime > 0
  && itime - c1_rtime < COOLOFF) {
    return;
  }

  c1_fstatus = 3;

  // Register a successful falling edge.
  c1_ftime = itime;
}

void c1_rise() {
  unsigned long itime = millis();

  c1_rstatus = 1;

  // If a rising edge has been registered
  // and the time since last rising edge is less than debounce time,
  // ignore!
  if(c1_rtime > 0
  && itime - c1_rtime < DEBOUNCE) {
    return;
  }

  c1_rstatus = 2;

  // If the time since last falling edge is less than colloff time,
  // ignore!
  if(itime - c1_ftime < COOLOFF) {
    return; // Too soon - cool off!
  }

  c1_rstatus = 3;

  c1_rtime = itime;
  c1++;
}

void c1_change() {
  unsigned long itime = millis();

  c1_rstatus = 1;

  // If a rising edge has been registered
  // and the time since last rising edge is less than debounce time,
  // ignore!
  if(c1_rtime > 0
  && itime - c1_rtime < DEBOUNCE) {
    return;
  }

  c1_rstatus = 2;

  // If the time since last falling edge is less than colloff time,
  // ignore!
  if(itime - c1_ftime < COOLOFF) {
    return; // Too soon - cool off!
  }

  c1_rstatus = 3;

  c1_rtime = itime;
  c1++;
}

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  Serial.begin(9600);
  while(!Serial);
  Serial.setTimeout(1000);

  pinMode(PIN_COUNTER_1, INPUT_PULLUP);
  digitalWrite(LED_BUILTIN, HIGH);
  enableInterrupt(PIN_COUNTER_1, c1_fall, FALLING);
  enableInterrupt(PIN_COUNTER_1, c1_rise, RISING);
}

void loop() {
  t = millis();
  output();
  delay(10);
}

If this library is used in projects spread over more than a single INO-file, i.e. if separate headers and code files are used, it breaks the linking process.

Because all code is simply put into a header file, the linker will produce a load of errors concerning multiple definitions. This cannot be catched by your include guards. For working in more than simple projects, this libray must be split into a separate code file (.cpp) and a header file containing solely declarations. I had the same problems already with the predecessor PinChangeInt.

Hi, I'm using EnableInterrupt as a submodule for one of my projects. I found a compiler bug regarding EnableInterrupt/examples/SimpleWithLibrary/Useless.h; the verbose output is as follows:

In file included from /var/folders/70/7_syjtnx1zb_t62jc3qwvk_w0000gn/T/buildb1edcb75b05118bd4250494061fe263d.tmp/sketch/EnableInterrupt/examples/SimpleWithLibrary/Useless.cpp:3:0:
/var/folders/70/7_syjtnx1zb_t62jc3qwvk_w0000gn/T/buildb1edcb75b05118bd4250494061fe263d.tmp/sketch/EnableInterrupt/examples/SimpleWithLibrary/Useless.h:15:29: fatal error: EnableInterrupt.h: No such file or directory
#include "EnableInterrupt.h"

And after a few minutes tinkering, I found a solution. Changing line 15 from #include <EnableInterrupt.h> to #include "../../EnableInterrupt.h". Not really sure why it gave me errors considering all the other .ino files in the examples directory seem to find the file just fine.

Pin change interrupts set on B0 and B1 were failing to trigger the appropriate functions.

Adding the following to the code directs mask to the right register and appears to solve the issue:

ifdef EI_ATTINY24

interruptMask = PCMSK1 & interruptMask;
...

ENDIF

Massive apologies in advance, first time I've posted a problem. Like the title says I get a compiling error due to attachInterrupt and multiple definition of vector 1 and 2. I've tried using different digital pins and including #define EI_NOTINT0 and #define EI_NOTINT1 in my sketch but I do not know what is going wrong. I've read that you are not meant to use serial.print but that surely can't be the problem? because serial print is a major function of Arduino prototyping.

I am using 3 pins to read 3 Hall effect sensors and migrated from using attachInterrupt to enableInterrupt as the prior does not accommodate more than 2 pins.

Below is the error message

Arduino: 1.8.3 (Linux), Board: "Arduino/Genuino Uno"

In file included from /local/XXXX/Arduino/flow_oct_v1/flow_oct_v1.ino:1:0:
/local/XXXX/Arduino/libraries/EnableInterrupt-master/EnableInterrupt.h:22:125: note: #pragma message: NOTICE: *** EnableInterrupt library version pre-0.9.6. This is not a problem. Keep calm, and carry on. ***
#pragma message("NOTICE: *** EnableInterrupt library version pre-0.9.6. This is not a problem. Keep calm, and carry on. ***")
^
WInterrupts.c.o (symbol from plugin): In function attachInterrupt': (.text+0x0): multiple definition of __vector_1'
sketch/flow_oct_v1.ino.cpp.o (symbol from plugin):(.text+0x0): first defined here
WInterrupts.c.o (symbol from plugin): In function attachInterrupt': (.text+0x0): multiple definition of __vector_2'
sketch/flow_oct_v1.ino.cpp.o (symbol from plugin):(.text+0x0): first defined here
collect2: error: ld returned 1 exit status
exit status 1
Error compiling for board Arduino/Genuino Uno.

-------------------------------------------------------------------------------------------------------------------------------------------And this is my sketch

#include <EnableInterrupt.h>

#define EI_NOTINT0
#define EI_NOTINT1

/*
Liquid flow rate sensor -DIYhacking.com Arvind Sanjeev

Measure the liquid/water flow rate using this code.
Connect Vcc and Gnd of sensor to arduino, and the
signal line to arduino digital pin 2.

*/

byte statusLed = 13;

// byte sensorInterrupt = 0; // 0 = digital pin 2
byte sensorPin1 = 5;

// The hall-effect flow sensor outputs approximately 4.5 pulses per second per
// litre/minute of flow.
float calibrationFactor = 4.5;

volatile byte pulseCount1;

float flowRate1;
unsigned int flowMilliLitres1;
unsigned long totalMilliLitres1;

unsigned long oldTime;

byte sensorPin2 = 4;
// The hall-effect flow sensor outputs approximately 4.5 pulses per second per
// litre/minute of flow.

volatile byte pulseCount2;

float flowRate2;
unsigned int flowMilliLitres2;
unsigned long totalMilliLitres2;

byte sensorPin3 = 7;

volatile byte pulseCount3;

float flowRate3;
unsigned int flowMilliLitres3;
unsigned long totalMilliLitres3;

void setup()
{

// Initialize a serial connection for reporting values to the host
Serial.begin(9600);

// Set up the status LED line as an output
pinMode(statusLed, OUTPUT);
digitalWrite(statusLed, HIGH); // We have an active-low LED attached

pinMode(sensorPin1, INPUT);
digitalWrite(sensorPin1, HIGH);

pinMode(sensorPin2, INPUT);
digitalWrite(sensorPin2, HIGH);

pinMode(sensorPin3, INPUT);
digitalWrite(sensorPin3, HIGH);

pulseCount1 = 0;
flowRate1 = 0.0;
flowMilliLitres1 = 0;
totalMilliLitres1 = 0;

pulseCount2 = 0;
flowRate2 = 0.0;
flowMilliLitres2 = 0;
totalMilliLitres2 = 0;

pulseCount3 = 0;
flowRate3 = 0.0;
flowMilliLitres3 = 0;
totalMilliLitres3 = 0;

oldTime = 0;

// The Hall-effect sensor is connected to pin 2 which uses interrupt 0.
// Configured to trigger on a FALLING state change (transition from HIGH
// state to LOW state)
// attachInterrupt(sensorInterrupt, pulseCounter, FALLING);

enableInterrupt(5, pulseCounter1, FALLING);

enableInterrupt(4, pulseCounter2, FALLING);

enableInterrupt(7, pulseCounter3, FALLING);

Serial.println("Qf,,Vf1,,Vf2,,Qr,,Vr1,,Vr2,,Qp,,Vp1,,Vp2,,");
}

/**

• Main program loop
  */
  void loop()
  {

  if((millis() - oldTime) > 1000) // Only process counters once per second
  {
  // Disable the interrupt while calculating flow rate and sending the value to
  // the host
  //detachInterrupt(sensorInterrupt);
  disableInterrupt(5);
  disableInterrupt(4);
  detachInterrupt(7);

  // Because this loop may not complete in exactly 1 second intervals we calculate
  // the number of milliseconds that have passed since the last execution and use
  // that to scale the output. We also apply the calibrationFactor to scale the output
  // based on the number of pulses per second per units of measure (litres/minute in
  // this case) coming from the sensor.
  flowRate1 = ((1000.0 / (millis() - oldTime)) * pulseCount1) / calibrationFactor;
  flowRate2 = ((1000.0 / (millis() - oldTime)) * pulseCount2) / calibrationFactor;
  flowRate3 = ((1000.0 / (millis() - oldTime)) * pulseCount3) / calibrationFactor;

  // Note the time this processing pass was executed. Note that because we've
  // disabled interrupts the millis() function won't actually be incrementing right
  // at this point, but it will still return the value it was set to just before
  // interrupts went away.
  oldTime = millis();

  // Divide the flow rate in litres/minute by 60 to determine how many litres have
  // passed through the sensor in this 1 second interval, then multiply by 1000 to
  // convert to millilitres.
  flowMilliLitres1 = (flowRate1 / 60) * 1000;
  flowMilliLitres2 = (flowRate2 / 60) * 1000;
  flowMilliLitres3 = (flowRate3 / 60) * 1000;

  // Add the millilitres passed in this second to the cumulative total
  totalMilliLitres1 += flowMilliLitres1;
  totalMilliLitres2 += flowMilliLitres2;
  totalMilliLitres3 += flowMilliLitres3;

  unsigned int frac;

  // Print the flow rate for this second in litres / minute
  Serial.print(int(flowRate1)); // Print the integer part of the variable
  Serial.print(",");
  Serial.print("L/min");
  Serial.print(",");
  //Serial.print("\t"); // Print tab space

  // Print the cumulative total of litres flowed since starting;
  Serial.print(totalMilliLitres1);
  Serial.print(",");
  Serial.print("mL");
  Serial.print(",");
  //Serial.print("\t"); // Print tab space
  Serial.print(totalMilliLitres1/1000);
  Serial.print(",");
  Serial.print("L");
  Serial.print("\t");

  // this migh not work****************************************
  Serial.print(",");
  // Print the flow rate for this second in litres / minute
  Serial.print(int(flowRate2)); // Print the integer part of the variable
  Serial.print(",");
  Serial.print("L/min");
  Serial.print(",");
  //Serial.print("\t"); // Print tab space

  // Print the cumulative total of litres flowed since starting;
  Serial.print(totalMilliLitres2);
  Serial.print(",");
  Serial.print("mL");
  Serial.print(",");
  // Serial.print("\t"); // Print tab space
  Serial.print(totalMilliLitres2/1000);
  Serial.print(",");
  Serial.print("L");
  Serial.print(",");
  Serial.print("\t");

  // Print the flow rate for this second in litres / minute
  Serial.print(int(flowRate3)); // Print the integer part of the variable
  Serial.print(",");
  Serial.print("L/min");
  Serial.print(",");
  //Serial.print("\t"); // Print tab space

  // Print the cumulative total of litres flowed since starting;
  Serial.print(totalMilliLitres3);
  Serial.print(",");
  Serial.print("mL");
  Serial.print(",");
  //Serial.print("\t"); // Print tab space
  Serial.print(totalMilliLitres3/1000);
  Serial.print(",");
  Serial.println("L");
  //*************************************************************

  // Reset the pulse counter so we can start incrementing again
  pulseCount1 = 0;
  pulseCount2 = 0;
  pulseCount3 = 0;

  // Enable the interrupt again now that we've finished sending output
  //attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
  enableInterrupt(5, pulseCounter1, FALLING);

  enableInterrupt(4, pulseCounter2, FALLING);

  enableInterrupt(7, pulseCounter3, FALLING);
  }
  }

/*
Insterrupt Service Routine
*/
void pulseCounter1()
{
// Increment the pulse counter
pulseCount1++;
}
void pulseCounter2()
{
// Increment the pulse counter
pulseCount2++;
}
void pulseCounter3()
{
// Increment the pulse counter
pulseCount3++;
}

Apologies again as I can only presume there must be a painfully obvious solution to those that know.
And thanks.
Michael

Hello, any chance of adding arduino nano?
tks

Thanks for this library,

Should I be able to use both this and external interrupts together?

just including this library with my code causes compile error.
I'm using a ProMicro (Leonardo) and IDE 1.8.1

#include <Keyboard.h>
#include <HID.h>
#include <Mouse.h>
//#include <EnableInterrupt.h>

#define pinA1 1 //Roller A
#define pinZ1 8 //Spinner

long cntX=0; //counter for mouse X-axis
long lastcntX=0;
float realX=0;
float incX= 0.5; // This gives approx correct speed on missile command default sensitivity 20
float incZ= 0.1; // high resolution spinner needs low value here.

void setup() {

// pinMode(pinZ1, INPUT_PULLUP);
// enableInterrupt(pinZ1,doZCount, CHANGE);

pinMode(pinA1, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(pinA1),doACountX,CHANGE);

Mouse.begin();
Keyboard.begin();
}

void loop() {
//send mouse update to usb
cntX = realX;
if(cntX!=lastcntX ){
Mouse.move((cntX-lastcntX),0);
lastcntX=cntX;
}
}

void doZCount() { // spinner is moving
realX = realX +incZ;
}

void doACountX() { // ball is moving
realX = realX +incX;
}

Build please v1.0.0 and remove pragma notice there
EnableInterrupt library version 0.9.7. This is not a problem. Keep calm, and carry on

Including both Softserial and EnableInterrupt produces a compile conflict. Both libraries appear to be going after the same interrupt vector.

How Do I use Sleep modes with this library?

I am thinking of using lowpower library

version=0.6.0 should be 0.8.1 😃
architectures=* could be avr 😃
paragraph= is kind of strange? 'Provides a ponsistent API'? 😕

Chuck.

This Library is having conflict with the software serial library. Is there a way around using the library with the softwareserial library?

Is there any chance of integrating esp8266 chips?

I tried to use this library to add pinChange interrupt capability to an existing sketch. When I simply added #include <EnableInterrupt.h> into my main sketch, the build failed with multiple duplicate references.
After exploring a bit I discovered that all I had to do was use the 'Simple' example, #include a reference one of my other libraries (which supports hardware with its own interrupt handler) and that build failed. I then created a very simple extension to 'Simple' example in which there was a secondary file with its own interrupt handler and was not surprised that that failed as well. (I'd include the source files here but don't see how to do it)

Also, the EnableInterrupt.h file is peppered with references to actual Arduino boards, not to the underlying processor. Consequently any board that is NOT included in the set will not be built properly, these include new Arduino designs or designs using AVR processors that are not 'official' Arduino designs.

My main sketch and a library I wrote are using EnableInterrupt. That means I have to include EnableInterrupt twice - in my main sketch and in my library.

The linker is giving me "multiple definition" errors. I've read about similar errors (https://forum.arduino.cc/index.php?topic=351281.15) and I believe it is caused by having the definitions inside the .h file instead of in a separate file.

Hi. I'm using Mega2560 and Analog pin A8 to A15.
I'm seeing strange behavior, using CHANGE, RISING or FALLING, any voltage change fire interrupt.
example, if it's on 0V and goes to 1V interrupt fire.
if it's 5V and goes to 4.9V interrupt fire.
Could you help me?

Sorry for my poor english!

Thanks a lot! This library save my life!

I'd be very interested in using your library in a project. Would it be possible for you to add a license to this library? Also would you be able to do LGPL, or BSD, or something similar? My company may not allow me to use this library if it's Apache 2.0. I am planning on completely open-sourcing my entire project, but I won't be able to do that unless this library uses a license that my company's lawyers are comfortable with.

Thanks so much for your consideration.

Hi, first of all i wanted to thank you for this wonderful job of yours.
I am using a Gboard Pro by Itead which is basically an Atmega2560 with Nrf24 IRQ pin attached to pin PE7 of the atmega. I can use your example code for generating the ISR on that pin but if i put the MCU i can't wake it up by that interrupt. Could you please explain how to achieve so? I suppose it is related to some flag that i read about in the datasheet but i am not that into technicalities.
Thanks in advance.

I am using DS3231 RTC with my Arduino Yun, and connect DS3231's SQW pin (generates interrupt at preset alarm time) to arduino pin 10. EnableInterrupt detects the interrupt, but it also detects it when I connect the wire to pin 9. It also detects it occasionally when I connect it to pin 11 - though it seems to be more like random. I am concerned about this because pins 9, 11 are supposed to control different operations in the future of my project.
What could be done? Should I better use A0-A5 pins instead?

I have been updating my libraries to use This new EnableInterrupt, but I was hitting a wall with this error message: multiple definition of `__vector_1', of course the compiler flags the error in code that has no relationship with the actual cause of the problem. So I just kept simplifying my code until i found what was left.

It turns out the if you use attachInterrupt(), (the Arduino Standard procedure) it produces this collision, now I am converting all of the old attachInterrupt() calls to enableInterrupt().

I think you should add this error message to your FAQ.

chuck.

edit: Solved this error only to create a new error.

I am using EnableInterrupt to add CTS/RTS handshaking to HardwareSerial. It works just fine, BUT, of course there is a but, If I want to use EnableInterrupt in my 'Application' level code, now I get
C:\Documents and Settings\user\My Documents\Arduino\libraries\EnableInterrupt/EnableInterrupt.h:783: multiple definition of `enableInterrupt(unsigned char, void (*)(), unsigned char)'

Here is the how I included EnableInterrupt in HardwareSerial.cpp:

#define EI_ARDUINO_INTERRUPTED_PIN // to support CTS handshaking 
#include "C:\Documents and Settings\user\My Documents\Arduino\libraries\EnableInterrupt\EnableInterrupt.h"
 //To support CTS handshaking 02AUG2015 Chuck Todd

Any Clues how to solve this collision?

Chuck.
Edit 27AUG15 19:41MDT

Here is a working solution, still testing, but so far it works. In the 'Application, or Application libraries' instead of #include <EnableInterrupt.h> use this:

extern void enableInterrupt(uint8_t interruptDesignator, void (*userFunction)(void), uint8_t mode);
extern void disableInterrupt(uint8_t interruptDesignator);

Chuck.

pin: fake70 PJ2 this is Pin Change Interrupt PCINT11
pin: fake71 PJ3 this is Pin Change Interrupt PCINT12
pin: fake72 PJ4 this is Pin Change Interrupt PCINT13
pin: fake73 PJ5 this is Pin Change Interrupt PCINT14
pin: fake74 PJ6 this is Pin Change Interrupt PCINT15
pin: fake75 PE6 this is External Interrupt INT6
pin: fake76 PE7 this is External Interrupt INT7

Must BE ||
pin: fake65 PJ2 this is Pin Change Interrupt PCINT11
pin: fake66 PJ3 this is Pin Change Interrupt PCINT12
pin: fake67 PJ4 this is Pin Change Interrupt PCINT13
pin: fake68 PJ5 this is Pin Change Interrupt PCINT14
pin: fake69 PJ6 this is Pin Change Interrupt PCINT15
pin: fake8 PE6 this is External Interrupt INT6
pin: fake76 PE7 this is External Interrupt INT7

http://www.atmel.com/Images/Atmel-2549-8-bit-AVR-Microcontroller-ATmega640-1280-1281-2560-2561_datasheet.pdf
https://www.arduino.cc/en/uploads/Hacking/PinMap2560sma_.png

Please take this with a grain of salt, as I have like 12 total hours of Arduino time under my belt, but I believe that there are a number of spots (e.g. the first line of ei_external328.h) where you have:

#if ! defined(EI_NOTINT0) && !defined (EI_NOTINT1)

Where what you meant is

#if ! ( defined(EI_NOTINT0) && defined (EI_NOTINT1) )

(I'm working on something that uses the V-USB library with another library (the PS2 keyboard library) that also wants an interrupt. The comments in the v-usb library struck terror in my heart, so I was loathe to change that, and the PS2 keyboard library is in pretty rough shape, so I modified that to use your library, because I couldn't fathom how I could modify the system attachInterrupt, which is apparently incompatible with v-usb.)

Will softwareserial cause problem with this library?
We are building our hardware and trying to shift UART operations to software serial. But its also necessary for use to use your library. But I want make sure before I can go further. I think SoftwareSerial also use PCINT.

In the pint-to-INT-List I see different things then in the official infos.

Official:
External Interrupts: 2 (interrupt 0), 3 (interrupt 1), 18 (interrupt 5), 19 (interrupt 4), 20 (interrupt 3), and 21 (interrupt 2). These pins can be configured to trigger an interrupt on a low value, a rising or falling edge, or a change in value. See the attachInterrupt() function for details.

this differs from your infos ... will it work on mega or not?

Hi,
is it possible that the isr is called when A0 detects a value higher than a prefixed value? For example when A0 detects a value greater than 100.
Thank you

cant use both as both are defining same vectors.is there a way to use them both by modifying?

\EnableInterrupt/EnableInterrupt.h:193: warning: only initialized variables can be placed into program memory area

const uint8_t PROGMEM digital_pin_to_port_bit_number_PGM[] = {
  0, // 0 == port D, 0
  1,
  2,
.......
  4,
  5,
};

The comma after the last 5 should not be there.

I looked through the EnableInterrupt.h code, I did not see any error checking for invalid pins. I have used the current version 0.8.1 to implement RTS/CTS handshaking for HardwareSerial::begin(baud,config,CTS_pin,RTS_pin);. I am concerned about passing invalid pin values to EnableInterrupt. I use a FALLING mode interrupt for the CTS_pin.
Is there a possible error value I can check to validate the Arduino Pin I passed to your library is valid?
How does the library handle a invalid pin?
Chuck.

I'm haven't this board so I can't see if this fantastic library is already compatible or not, but as anywhere is said it is, I'd like to know if this compatibility exists, and if it doesn't, ask for it.
Thanks!

my setup:

#define EI_NOTPORTB
// #define EI_NOTPORTC 
#define EI_NOTPORTD
#define EI_NOTEXTERNAL
#include <EnableInterrupt.h>

errors:

/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h: In function 'void __vector_5()':
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1192:19: error: 'portSnapshotD' was not declared in this scope
   changedPins   = portSnapshotD ^ current;
                   ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1193:19: error: 'risingPinsPORTD' was not declared in this scope
   tmp           = risingPinsPORTD & current;
                   ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1194:19: error: 'fallingPinsPORTD' was not declared in this scope
   interruptMask = fallingPinsPORTD & ~current;
                   ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1205:31: error: 'portDFunctions' was not declared in this scope
   if (interruptMask & _BV(0)) portDFunctions.pinZero();
                               ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1206:31: error: 'portDFunctions' was not declared in this scope
   if (interruptMask & _BV(1)) portDFunctions.pinOne();
                               ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1207:31: error: 'portDFunctions' was not declared in this scope
   if (interruptMask & _BV(2)) portDFunctions.pinTwo();
                               ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1208:31: error: 'portDFunctions' was not declared in this scope
   if (interruptMask & _BV(3)) portDFunctions.pinThree();
                               ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1209:31: error: 'portDFunctions' was not declared in this scope
   if (interruptMask & _BV(4)) portDFunctions.pinFour();
                               ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1210:31: error: 'portDFunctions' was not declared in this scope
   if (interruptMask & _BV(5)) portDFunctions.pinFive();
                               ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1211:31: error: 'portDFunctions' was not declared in this scope
   if (interruptMask & _BV(6)) portDFunctions.pinSix();
                               ^
/Users/hwestbrook/Documents/Arduino/libraries/EnableInterrupt/EnableInterrupt.h:1212:31: error: 'portDFunctions' was not declared in this scope
   if (interruptMask & _BV(7)) portDFunctions.pinSeven();
                               ^

It compiles just fine if port c is disabled too

Hi GreyGnome, is it possible to get the Lib work with an 328PB ?
Would be great Thx.

Bump from 0.9.6 to 0.9.8

Is there any chance to get these chips supported in the library?

They all have a single external interrupt pin, pin change interrupts on all pins and are supported in the Arduino IDE through David A. Mellis's cores available at https://github.com/damellis/attiny.

See http://fc04.deviantart.net/fs70/f/2013/038/3/7/attiny_web_by_pighixxx-d5u4aur.png for reference.

I have tried 3 examples, and none of them compiles. I am using Arduino 1.0.5 IDE. The following are just examples, there are many more errors.

EnableInterrupt OOSimple
OOSimple.ino: In function 'void* createSimple()':
OOSimple:10: error: previous declaration of 'void* createSimple()' with 'C++' linkage

EnableInterruptTest:183: error: 'ByteBuffer' does not name a type
EnableInterruptTest.ino: In function 'void quicfunc0()':
EnableInterruptTest:228: error: 'PCintPort' has not been declared

SimpleWithLibrary.cpp.o: In function UselessClass': /Useless.h:19: undefined reference toUselessClass::init(unsigned char, unsigned char)'

In my own code, when I include the header file in just my library cpp file, I get
C:...\mcHC_SR04.cpp:81: error: 'disableInterrupt' was not declared in this scope
To make the code work, I had to include the header in both the main sketch and the library file. The #define LIBCALL_ENABLEINTERRUPT worked in either file.

GreyGnome,
I'm in the process of adding CTS/RTS handshaking to the HardwareSerial object. I had previously used pinInterrupt with arduino 1.0. With the New 1.6.5 IDE they have totally changed Hardware Serial. The TX buffer is now a member of the class instead of a Global buffer.
The complier will not allow (interruptFunctionType)&this->_cts_clear_irq. It will allow (interruptFunctionType)&HardwareSerial::_cts_clear_irq. (the compiler did not force _cts_clear_irq to be a STATIC member, it used a uint16_t off the stack as the object pointer when I tried it.) But the instance pointer this was not set to the correct value.

I am at a loss on how to correctly access these internal buffers from a irq.

any suggestions?
Chuck.

Edit: add:
Can you make another enableInterrupt() that also accepts a this value? you would have to custom code the callback to push the this value on the stack before the class member callback.
Reading through the other open issues, it looks like the pinInterruptNumber variable would enable a workaround. Adding support to emulate a object member callback would increase the complexity of every callback too much.
Could you redefine the callback function with the pinNumber as a parameter? In your code these all would be constants in the if(interruptmask&_BV(x))portn.callback[x](pinNumber);

I am using your library which performs great. But I wanted to use it with nrf24. For nrf Radio modules I am using radiohead's library and they both seem to have some conflict. I checked that it has to do with the driver RH_RF24.h because commenting it causes no error.
error is .
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
C:\Users\ASUS-PC\AppData\Local\Temp\build6046962854557047475.tmp/core.a(WInterrupts.c.o): In function __vector_1': C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/WInterrupts.c:309: multiple definition of__vector_1'
powerDownWakeExternalInterrupt_MY.cpp.o:C:\Program Files (x86)\Arduino\libraries\EnableInterrupt/EnableInterrupt.h:948: first defined here
C:\Users\ASUS-PC\AppData\Local\Temp\build6046962854557047475.tmp/core.a(WInterrupts.c.o): In function attachInterrupt': C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/WInterrupts.c:39: multiple definition of__vector_2'
powerDownWakeExternalInterrupt_MY.cpp.o:C:\Program Files (x86)\Arduino\libraries\EnableInterrupt/EnableInterrupt.h:473: first defined here
collect2.exe: error: ld returned 1 exit status
Error compiling.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I would also try to contact radio head's author.
Any Idea How I resolve this.
I am attaching interrupts on 2,3,4,5,6 pin on Pro mini. Also using a LowPower.h but thats not causing this I have check.
Thanks in advance.

Do you think it's feasible to change the callback function type to a void function that has a void pointer parameter? This would allow for passing state to the callback function, eliminating the need to declare multiple functions for each instance of a particular object (as your ooSimple example would require). I know that storing the void pointers may roughly double the library's memory usage and may complicate the #defines. Regardless, I believe this would be really useful.

Hi Mike,
I've been testing the Simple example on a LowPower labs Moteino Mega (ATMEGA1284p) .
I believe I may have encountered a defect in the EnableInterrupt library I downloaded on Nov 16 2015.

My tests using a single pushbutton were only partially successful. I was able to run the Simple example successfully on pins 0 to 7, A0 to A7, and 10 and 11 ... but was unable to activate pin change interrupts on pins 12 through 23. I have confirmed that the hardware and wiring is functioning correctly.

I'd be happy to work with you to confirm and resolve.

I've run your Mighty1284p example, but I'm afraid I don't understand the expected outcome.
I am happy to help if you give me a little guidance.

John
[email protected]

Any chance you could do another release to force the library registries to pick up the change to the pragma message? I think this library is wonderful and use it all the time so it would be nice to stop seeing the outdated pragma with every build.

Thanks!

Nice Lib. I had to move around the folders and files a little before my sketch compiled.
The current version of the Arduino IDE (1.6.4) has a standardised method to include external libraries.
By default it places the files from a ZIP file into a directory under the MyDocuments/Arduino folder.

When included using the libarary manager, it expects the header file to be included in the top folder of the libary file, and that header file is then inserted in the source of the sketch. Thus it requires the "EnableInterrupt.h" to be moved to the top folder of the ZIP file. Only the file to be included in the sketch is needed since all .h files found in the top folder are inserted in the sketch source. The description is currently not visible in the list within the IDE.

A manual on how to organise external libraries is documented on http://www.arduino.cc/en/Guide/Libraries

Hello, I get the following error when I try to compile the code. Can you please provide some guidance on this?

In file included from Interrupt.ino:1:
/Users/arjunmehta94/Documents/Arduino/libraries/EnableInterrupt-master/EnableInterrupt.h: In function 'void __vector_3()':
/Users/arjunmehta94/Documents/Arduino/libraries/EnableInterrupt-master/EnableInterrupt.h:976: error: 'struct functionPointersPortB' has no member named 'pinSix'
/Users/arjunmehta94/Documents/Arduino/libraries/EnableInterrupt-master/EnableInterrupt.h:977: error: 'struct functionPointersPortB' has no member named 'pinSeven'

I realize this has been reported prior, however Im not getting how to resolve it.
I have a Rotary Encoder/Switch
I want the switch to enter and exit sleep mode.
I have the switch on pin4 of my uno.

void setup()
{
...
enableInterrupt(2, intrEncChange1, CHANGE); //encoder interrupts
enableInterrupt(3, intrEncChange2, CHANGE);
enableInterrupt(4, intrEncChangeS, CHANGE);
...
}

void intrEncChangeS()
{
if (sw)
delay(1);
if (digitalRead(SencPin) == encSW)
return;
encSW = !encSW;
if (encSW)
sleepNow();
sw = false;
}
void intrEncChange1() //Read on interrupt Right turn - Fast +5
{
if (moving)
delay(1);
if (digitalRead(encPin1) == enc1)
return;
enc1 = !enc1;
if (enc1 && !enc2)
encVal += 5;
moving = false;
update();
}
void intrEncChange2() //Read on interrupt Left turn - Slow -1
{
if (moving)
delay(1);
if (digitalRead(encPin2) == enc2)
return;
enc2 = !enc2;
if (enc2 && !enc1)
encVal -= 1;
moving = false;
update();
}
void sleepNow()
{
disableInterrupt(4);
enableInterrupt(4, wakeUpNow, LOW);
set_sleep_mode(SLEEP_MODE_STANDBY);// Choose our preferred sleep mode
sleep_enable();// Set sleep enable (SE) bit
sleep_mode();// Put the device to sleep
sleep_disable();// Upon waking up, sketch continues from this point.
disableInterrupt(4);
enableInterrupt(4, intrEncChangeS, CHANGE);
}

How do I code this so that the switch works the way I need it to in order to resume from sleep mode?

When I try to include EnableInterrupt with HFM69.h I get multiple definition of:
__vector_1
__vector_2

Are these ISR that I should modify in the RFM69 library ?

Sid

I am getting this errors:

C:\Users\marco\AppData\Local\Temp\buildca530f920e52af2e7c8f67a769a556af.tmp/core\core.a(WInterrupts.c.o): In function `__vector_1':
C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/WInterrupts.c:309: multiple definition of `__vector_1'
sketch\MySensor_Keypad.ino.cpp.o:C:\Users\marco\Documents\MySensors\libraries\EnableInterrupt/EnableInterrupt.h:1284: first defined here

C:\Users\marco\AppData\Local\Temp\buildca530f920e52af2e7c8f67a769a556af.tmp/core\core.a(WInterrupts.c.o): In function `nothing':
C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/WInterrupts.c:35: multiple definition of `__vector_2'
sketch\MySensor_Keypad.ino.cpp.o:C:\Users\marco\Documents\MySensors\libraries\EnableInterrupt/EnableInterrupt.h:1011: first defined here

I did not figure out easily how __vector_1 and __vector_2 are defined/used since there are preprocessor macros involved.

• The EnableInterrupt examples compile correctly in my environment.
• I am compiling for board Arduino Pro or Pro Mini (ATmega328 3.3V 8MHz).
• I am using the MySensors library. It seems to be conflicting with this.

Any idea on how to solve?
Thank you!

Hi,

Quick question, how can I get it working with Teensy 3.2?

I understandably get the Unsupported Arduino platform error.

Thanks!

Hi, I'm not sure where to ask this but here's my problem:

I'm unable to compile any sketches when hi speed mode is enabled, including the examples.

Here's the compiler error:

In file included from /home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:829:0,
                 from HiSpeedTest.ino:52:
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h: In function ‘void enableInterrupt(uint8_t, interruptFunctionType, uint8_t)’:
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:4:3: error: ‘risingPinsPORTB’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:9:3: error: ‘risingPinsPORTC’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:14:3: error: ‘risingPinsPORTD’ was not declared in this scope
In file included from /home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:843:0,
                 from HiSpeedTest.ino:52:
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:22:3: error: ‘fallingPinsPORTB’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:27:3: error: ‘fallingPinsPORTC’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:32:3: error: ‘fallingPinsPORTD’ was not declared in this scope
In file included from /home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:866:0,
                 from HiSpeedTest.ino:52:
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:44:3: error: ‘portSnapshotB’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:55:3: error: ‘portSnapshotC’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:66:3: error: ‘portSnapshotD’ was not declared in this scope
In file included from /home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:957:0,
                 from HiSpeedTest.ino:52:
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h: In function ‘void disableInterrupt(uint8_t)’:
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:78:3: error: ‘risingPinsPORTB’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:79:3: error: ‘fallingPinsPORTB’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:86:3: error: ‘risingPinsPORTC’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:87:3: error: ‘fallingPinsPORTC’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:94:3: error: ‘risingPinsPORTD’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/utility/ei_PinChange328.h:95:3: error: ‘fallingPinsPORTD’ was not declared in this scope
In file included from HiSpeedTest.ino:52:0:
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h: In function ‘void __vector_3()’:
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1269:19: error: ‘portSnapshotB’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1270:19: error: ‘risingPinsPORTB’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1271:19: error: ‘fallingPinsPORTB’ was not declared in this scope
In file included from HiSpeedTest.ino:52:0:
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h: In function ‘void __vector_4()’:
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1328:19: error: ‘portSnapshotC’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1329:19: error: ‘risingPinsPORTC’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1330:19: error: ‘fallingPinsPORTC’ was not declared in this scope
In file included from HiSpeedTest.ino:52:0:
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h: In function ‘void __vector_5()’:
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1380:19: error: ‘portSnapshotD’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1381:19: error: ‘risingPinsPORTD’ was not declared in this scope
/home/engwan/sketchbook/libraries/EnableInterrupt/EnableInterrupt.h:1382:19: error: ‘fallingPinsPORTD’ was not declared in this scope

EDIT: I tried using older versions and I got 0.6.3 to compile. Versions after that give the same error above.

Hello,

I'm using your excellent library to implement RC Pwm timing on an arduino uno. The interrupt routine I use is identical between pins, but needs to store separate data for separate pins. is there anyway for my interrupt routine to easily access which pin generated the interrupt request so I can use the same code for both pin interrupts with an array?

thanks very much!

// Test.h

ifndef _TEST_h

define _TEST_h

if defined(ARDUINO) && ARDUINO >= 100

#include "arduino.h"

else

#include "WProgram.h"

endif

define ADC_EXTERNAL_PIN 2

include <EnableInterrupt.h>

class TestClass
{
protected:
interruptFunctionType pInt;

public:
TestClass();
void init();
void start();
void stop();
static void _interruptFunction();
};

endif

// Test.cpp

include "Test.h"

void TestClass::init()
{

pInt = static_cast( TestClass::_interruptFunction);
}

void TestClass::start()
{
enableInterrupt (ADC_EXTERNAL_PIN, pInt , FALLING);
}
void TestClass::stop()
{
disableInterrupt (ADC_EXTERNAL_PIN);
}

this code not compiled

When debugging code I placed in a library, the arduinoInterruptedPin variable would have been a big help, but was not available. The reason is that variables can not be defined in header files that are included in multiple source files. When they are, a multiple definition error is generated. The EnableInterrupt library is implemented as a header file with 2 sections,

• One that is included in all the files that use the library - the header section, and
• One that must be included in only the top level sketch (source file) - the implementation section

My suggested solution is to

• Move the variable definition to the implementation section
• Add a function prototype to the header section
• Implement the function in the implementation section

In the Arduino C implementation, function prototypes can be included via a header file in multiple source files without any problem. The function should simply return the value of the variable. This modification should allow all existing code that uses the variable to continue operating without any changes, and will allow libraries to also access the interrupting pin numbers.

The following is code that I have tested. You may use it if you like, or change what ever makes sense. I am not trying to tell you what to do, just making a suggestion.

#ifdef EI_ARDUINO_INTERRUPTED_PIN
uint8_t arduinoInterruptedLastPin();      // function prototype
#endif


#ifndef LIBCALL_ENABLEINTERRUPT           // This is the magic dividing line
                                          // between prototypes and implementation
#ifdef EI_ARDUINO_INTERRUPTED_PIN
volatile uint8_t arduinoInterruptedPin=0; // This was moved from above the line

uint8_t arduinoInterruptedLastPin(){      // function implementation
  return arduinoInterruptedPin;
}
#endif

I also defined the variable as volatile because it is set via an interrupt routine.