Function interruptHandler

samples/Basic_Interrupts/app/application.cpp:27–59

@brief Low-level interrupt handler * @note An interrupt handling callback must have the IRAM_ATTR attribute. * Interrupt processing code should be as short as possible. * You could perhaps set a flag, then check it in your main code (timers, etc) or read actual * pin state and save it to a global variable. * Avoid doing things like calling malloc(), new(), reading Flash memory. * If yo

 *  If your application is not timing-critical, then use an InterruptDelegate callback instead.
 */
void IRAM_ATTR interruptHandler()
{
	// For this example, we just toggle the state of an output pin.
	bool state = digitalRead(TOGGLE_PIN);
	digitalWrite(TOGGLE_PIN, !state);

	// Example of how you can queue a callback from inside a regular interrupt handler
	const unsigned MAX_TOGGLE_COUNTS = 10;
	++interruptToggleCount;
	if(interruptToggleCount > MAX_TOGGLE_COUNTS) {
		System.queueCallback(showInterruptToggleCount, interruptToggleCount);
		/*
		 * Note that `queueCallback` also supports std::function arguments, so we can use lambdas,
		 * class methods, etc.
		 *
		 * For example, we could use a lambda to capture to capture the instantaneous value of 'toggleCount':
		 *
		 * 	```
		 * 	System.queueCallback([toggleCount]() {
		 * 		showInterruptToggleCount(toggleCount);
		 * 	};
		 * 	```
		 *
		 * IMPORTANT: the lambda inherits this function's context, so will be stored in IRAM which
		 * is a very limited resource. The lambda is therefore best suited to simple 'glue' code.
		 *
		 * IMPORTANT: Avoid using std::bind from interrupt handlers because it may attempt to allocate
		 * storage on the heap; this will likely crash the system.
		 *
		 */
		interruptToggleCount = 0;
	}
}

/** @brief Example of an InterruptDelegate function
 *  @note Unlike interruptHandler() above, this function is not called directly from an interrupt so there