Change in the interrupt processing flow.

AttachInterrupt() should be called for a capable class (digital input is the only class from the classic HAL instances).
ProcessInterrupt() function will be called from the HalInstance class to handle the interrupt notification.
That function could register it's HalInstance object to be called from the normal run with the EBF ProcessInterrupt(), which
will use the messaging system to call the HalInstance Process() function.

Author: 4project-co-il

examples/Digital-Interrupts/Digital-Interrupts.ino

@@ -116,21 +116,22 @@ void setup()
 	// Built-in LED on digital output #13 will be used
 	led.Init(13);
 
-	// Initialize button on digital input 2
+	// Initialize button on digital input 2 for any change of the value
 	// Internal pullup resistor will be used to minimize bouncing
 	button.Init(2, onButtonChange, EBF_DigitalInput::InterruptMode::MODE_CHANGE, true);
 
-	// Since interrupts processing is enabled for that example, EBF will try to use
-	// hardware interrupts for the button digital input since it's using interrupt
-	// enabled line 2. On Arduino UNO lines 2 and 3 are capable to produce interrupts
+	// AttachInterrupt() should be called for the button instance to utilize
+	// the hardware interrupt line based on the configuration passed in Init() function
+	// On Arduino UNO lines 2 and 3 are capable to produce interrupts.
 	// When interrupts are used, polling is disabled on those pins
 	// Pay attention that there is no change in the initialization of the digital input
 	// object. The same onButtonChange function will be called.
+	button.AttachInterrupt();
 }
 
 void loop()
 {
 	// Let EBF to do all the processing
 	// Your logic should be done in the callback functions
 	EBF.Process();
-}
+}

src/Core/EBF_DigitalInput.cpp

@@ -28,7 +28,16 @@ uint8_t EBF_DigitalInput::Init(
 
 	if (callbackFunc != NULL) {
 		lastValue = digitalRead(pinNumber);
+	} else {
+		// No callback. No need to poll in that case
+		pollIntervalMs = EBF_NO_POLLING;
+	}
 
+	return EBF_OK;
+}
+
+uint8_t EBF_DigitalInput::AttachInterrupt()
+{
 #ifdef EBF_USE_INTERRUPTS
 		uint8_t interruptNumber = NOT_AN_INTERRUPT;
 
@@ -43,14 +52,12 @@ uint8_t EBF_DigitalInput::Init(
 				// No need to poll
 				pollIntervalMs = EBF_NO_POLLING;
 			}
+
+			return EBF_OK;
 		}
 #endif
-	} else {
-		// No callback. No need to poll in that case
-		pollIntervalMs = EBF_NO_POLLING;
-	}
 
-	return EBF_OK;
+	return EBF_INVALID_STATE;
 }
 
 void EBF_DigitalInput::SetPollInterval(uint32_t ms)
@@ -128,6 +135,17 @@ uint8_t EBF_DigitalInput::Process()
 	return EBF_OK;
 }
 
+void EBF_DigitalInput::ProcessInterrupt()
+{
+	// This function is called from ISR.
+	// For DigitalInput, call the callback function to pass the pcontrol to user
+	// The user can call EBF.ProcessInterrupt() function to pass the control
+	// back to the EBF, which will call user callback again from normal run
+	ProcessCallback();
+
+	// The interrupt register is cleared by the arduino code
+}
+
 uint8_t EBF_DigitalInput::GetValue()
 {
 	return digitalRead(pinNumber);

src/Core/EBF_DigitalInput.h

@@ -27,8 +27,10 @@ class EBF_DigitalInput : protected EBF_HalInstance {
 			uint8_t pinNumber,
 			EBF_CallbackType callbackFunc,
 			InterruptMode isrMode = InterruptMode::MODE_CHANGE,
-			bool internelPullup = false
+			bool internalPullup = false
 		);
+		// Call to attach the device to an interrupt line
+		uint8_t AttachInterrupt();
 
 		uint8_t GetValue();
 		uint8_t GetLastValue();
@@ -37,6 +39,7 @@ class EBF_DigitalInput : protected EBF_HalInstance {
 
 	protected:
 		uint8_t Process();
+		void ProcessInterrupt();
 		virtual void ProcessCallback() { callbackFunc(); }
 		EBF_CallbackType callbackFunc;
 		uint8_t pinNumber;

src/Core/EBF_HalInstance.h

@@ -38,8 +38,8 @@ class EBF_HalInstance {
 		uint8_t Init(HAL_Type type, uint8_t id);
 		// Virtual function that will be called to process the data
 		virtual uint8_t Process() = 0;
-		// Virtual function that will be called to process the callback function
-		virtual void ProcessCallback() { }
+		// Virtual function that will be called to process the interrupt
+		virtual void ProcessInterrupt() { }
 
 		static uint8_t GetNumberOfInstances();
 		uint32_t GetPollingInterval();

src/Core/EBF_Logic.cpp

@@ -318,7 +318,7 @@ void EBF_Logic::HandleIsr(uint8_t interruptNumber)
 	if (pHalIsr[interruptNumber] != NULL) {
 		// Next process call is done from ISR
 		isRunFromISR = 1;
-		pHalIsr[interruptNumber]->ProcessCallback();
+		pHalIsr[interruptNumber]->ProcessInterrupt();
 		isRunFromISR = 0;
 	}
 }