use shared pin FD cache

resolves #1026

Author: 2bndy5

examples_pico/interruptConfigure.cpp

@@ -287,7 +287,7 @@ void loop()
  */
 void interruptHandler(uint gpio, uint32_t events)
 {
-    if (gpio != IRQ_PIN && !(events | GPIO_IRQ_EDGE_FALL)) {
+    if (gpio != IRQ_PIN && !(events & GPIO_IRQ_EDGE_FALL)) {
         // the gpio pin and event does not match the configuration we specified
         return;
     }

utility/SPIDEV/gpio.cpp

@@ -11,18 +11,16 @@
 #include <sys/ioctl.h> // ioctl()
 #include <errno.h>     // errno, strerror()
 #include <string.h>    // std::string, strcpy()
-#include <map>
 #include "gpio.h"
 
 // instantiate some global structs to setup cache
 // doing this globally ensures the data struct is zero-ed out
-typedef int gpio_fd; // for readability
-std::map<rf24_gpio_pin_t, gpio_fd> cachedPins;
 struct gpio_v2_line_request request;
 struct gpio_v2_line_values data;
 
-// initialize static member.
+// initialize static members.
 int GPIOChipCache::fd = -1;
+std::map<rf24_gpio_pin_t, gpio_fd> GPIOChipCache::cachedPins = std::map<rf24_gpio_pin_t, gpio_fd>();
 
 void GPIOChipCache::openDevice()
 {
@@ -97,8 +95,8 @@ void GPIO::open(rf24_gpio_pin_t port, int DDR)
     }
 
     // check if pin is already in use
-    std::map<rf24_gpio_pin_t, gpio_fd>::iterator pin = cachedPins.find(port);
-    if (pin == cachedPins.end()) { // pin not in use; add it to cached request
+    std::map<rf24_gpio_pin_t, gpio_fd>::iterator pin = gpioCache.cachedPins.find(port);
+    if (pin == gpioCache.cachedPins.end()) { // pin not in use; add it to cached request
         request.offsets[0] = port;
         request.fd = 0;
     }
@@ -127,25 +125,25 @@ void GPIO::open(rf24_gpio_pin_t port, int DDR)
         throw GPIOException(msg);
         return;
     }
-    cachedPins.insert(std::pair<rf24_gpio_pin_t, gpio_fd>(port, request.fd));
+    gpioCache.cachedPins.insert(std::pair<rf24_gpio_pin_t, gpio_fd>(port, request.fd));
 }
 
 void GPIO::close(rf24_gpio_pin_t port)
 {
-    std::map<rf24_gpio_pin_t, gpio_fd>::iterator pin = cachedPins.find(port);
-    if (pin == cachedPins.end()) {
+    std::map<rf24_gpio_pin_t, gpio_fd>::iterator pin = gpioCache.cachedPins.find(port);
+    if (pin == gpioCache.cachedPins.end()) {
         return;
     }
     if (pin->second > 0) {
         ::close(pin->second);
     }
-    cachedPins.erase(pin);
+    gpioCache.cachedPins.erase(pin);
 }
 
 int GPIO::read(rf24_gpio_pin_t port)
 {
-    std::map<rf24_gpio_pin_t, gpio_fd>::iterator pin = cachedPins.find(port);
-    if (pin == cachedPins.end() || pin->second <= 0) {
+    std::map<rf24_gpio_pin_t, gpio_fd>::iterator pin = gpioCache.cachedPins.find(port);
+    if (pin == gpioCache.cachedPins.end() || pin->second <= 0) {
         throw GPIOException("[GPIO::read] pin not initialized! Use GPIO::open() first");
         return -1;
     }
@@ -164,8 +162,8 @@ int GPIO::read(rf24_gpio_pin_t port)
 
 void GPIO::write(rf24_gpio_pin_t port, int value)
 {
-    std::map<rf24_gpio_pin_t, gpio_fd>::iterator pin = cachedPins.find(port);
-    if (pin == cachedPins.end() || pin->second <= 0) {
+    std::map<rf24_gpio_pin_t, gpio_fd>::iterator pin = gpioCache.cachedPins.find(port);
+    if (pin == gpioCache.cachedPins.end() || pin->second <= 0) {
         throw GPIOException("[GPIO::write] pin not initialized! Use GPIO::open() first");
         return;
     }

utility/SPIDEV/gpio.h

@@ -15,6 +15,7 @@
 
 #include <stdexcept>
 #include <cstdint>
+#include <map>
 #include "linux/gpio.h" // gpiochip_info
 
 typedef uint16_t rf24_gpio_pin_t;
@@ -35,6 +36,8 @@ class GPIOException : public std::runtime_error
     }
 };
 
+typedef int gpio_fd; // for readability
+
 /// A struct to manage the GPIO chip file descriptor.
 /// This struct's destructor should close any cached GPIO pin requests' file descriptors.
 struct GPIOChipCache
@@ -48,6 +51,12 @@ struct GPIOChipCache
     /// struct use the same file descriptor.
     static int fd;
 
+    /// @brief The map of pin numbers to their corresponding file descriptors.
+    ///
+    /// Because this member is static, all instances (& derivative instances) of this
+    /// struct use the same mapping.
+    static std::map<rf24_gpio_pin_t, gpio_fd> cachedPins;
+
     /// Open the File Descriptor for the GPIO chip
     void openDevice();
 

utility/SPIDEV/interrupt.cpp

@@ -133,14 +133,21 @@ int attachInterrupt(rf24_gpio_pin_t pin, int mode, void (*function)(void))
     IrqPinCache irqPinCache;
     irqPinCache.fd = request.fd;
     irqPinCache.function = function;
-    std::pair<std::map<rf24_gpio_pin_t, IrqPinCache>::iterator, bool> indexPair = irqCache.insert(std::pair<rf24_gpio_pin_t, IrqPinCache>(pin, irqPinCache));
 
+    std::pair<std::map<rf24_gpio_pin_t, IrqPinCache>::iterator, bool> indexPair = irqCache.insert(std::pair<rf24_gpio_pin_t, IrqPinCache>(pin, irqPinCache));
     if (!indexPair.second) {
         // this should not be reached, but indexPair.first needs to be the inserted map element
         throw IRQException("[attachInterrupt] Could not cache the IRQ pin with function pointer");
         return 0;
     }
 
+    std::pair<std::map<rf24_gpio_pin_t, gpio_fd>::iterator, bool> gpioPair = irqChipCache.cachedPins.insert(std::pair<rf24_gpio_pin_t, gpio_fd>(pin, request.fd));
+    if (!gpioPair.second) {
+        // this should not be reached, but indexPair.first needs to be the inserted map element
+        throw IRQException("[attachInterrupt] Could not cache the GPIO pin's file descriptor");
+        return 0;
+    }
+
     // create and start thread
     pthread_mutex_lock(&irq_mutex);
     pthread_create(&indexPair.first->second.id, nullptr, poll_irq, &indexPair.first->second);
@@ -157,8 +164,9 @@ int detachInterrupt(rf24_gpio_pin_t pin)
     }
     pthread_cancel(cachedPin->second.id);     // send cancel request
     pthread_join(cachedPin->second.id, NULL); // wait till thread terminates
-    close(cachedPin->second.fd);
     irqCache.erase(cachedPin);
+    // reconfigure the pin for basic `digitalRead()`
+    GPIO::open(pin, GPIO::DIRECTION_IN);
     return 1;
 }
 

utility/SPIDEV/interrupt.h

@@ -46,7 +46,7 @@ struct IrqPinCache
 int attachInterrupt(rf24_gpio_pin_t pin, int mode, void (*function)(void));
 
 /**
- * Will cancel the interrupt thread, close the filehandle and release the pin.
+ * Will cancel the interrupt thread and re-configure the pin for `digitalRead()` use.
  */
 int detachInterrupt(rf24_gpio_pin_t pin);