feat: count pulses instead of just edges

This gives a couple notable benefits:
* It handles debouncing on both edges of the pulse.
* It allows the user to configure a different pulse width, which could
  be used for a fixture lid switch where the length of a "valid" test is
  known as a means to reject invalid pulses. For example, if a test
  takes at least 30 seconds, the minimum pulse width could be set to
  that, allowing for an operator closing a fixture and reopening it due
  to a setup issue or something.

Author: sophec

CMakeLists.txt

@@ -26,6 +26,19 @@ target_link_libraries("${PROJECT_NAME}"
 
 target_compile_features("${PROJECT_NAME}" PUBLIC cxx_std_20)
 
+if (DEFINED MIN_PULSE_WIDTH_US)
+  if (MIN_PULSE_WIDTH_US GREATER_EQUAL 10)
+    target_compile_definitions("${PROJECT_NAME}" PRIVATE
+      "-DCONFIG_MIN_PULSE_WIDTH_US=${MIN_PULSE_WIDTH_US}"
+    )
+  else()
+    message(FATAL_ERROR
+      "Invalid minimum pulse width: ${MIN_PULSE_WIDTH_US}\n"
+      "MIN_PULSE_WIDTH_US must be a number >= 10."
+    )
+  endif()
+endif()
+
 option(USB_SERIAL "Use USB serial instead of UART" OFF)
 
 # add -DUSB_SERIAL=ON when configuring to use USB (9600 baud) instead of UART

README.md

@@ -4,7 +4,9 @@ This project uses a Raspberry Pi Pico to identify and store various information
 about a system/fixture, settable and retrievable over UART or USB. Additionally,
 writing can be disabled by jumping GPIO pins 14 and 15 together (pins 19 and 20
 on the board), and GPIO 13 (pin 17 on the board) can be switched to GND and used
-as a falling edge counter, such as for a fixture lid switch.
+as a pulse counter, such as for a fixture lid switch. This pin is active low and
+counts any low pulse longer than a minimum time period (configurable by with a
+CMake variable).
 
 This project makes use of a Pi Pico and a MIKROE EEPROM 3 Click. The I2C lines
 for the EEPROM should be connected to GPIOs 16 (SDA) and 17 (SCL) (pins 21 and
@@ -17,7 +19,10 @@ read the Pico's unique 64-bit identifier as a hex string, but of course this is
 read-only. The idea is that the Pico's serial number can always be used to
 uniquely identify any device, as no two Picos have the same serial.
 
-The EEPROM specifies up to 1,000,000 writes per flash cell (per 4-byte word).
+The EEPROM specifies up to 1,000,000 writes per flash cell (per 4-byte word). In
+theory, this means we can count up to 1 million pulses reliably, as no wear
+leveling is implemented at the moment. This could be added in the future to
+trivially multiply the maximum count.
 
 | Field | Access | Description |
 |---|---|---|
@@ -32,7 +37,7 @@ The EEPROM specifies up to 1,000,000 writes per flash cell (per 4-byte word).
 | `USER3` | Read-write | General-purpose field 3 |
 | `USER4` | Read-write | General-purpose field 4 |
 | `SERIAL` | Read-only | Pico's unique 64-bit serial number |
-| `EDGECOUNT?` | Read-only | Falling edge count on GP13 (board pin 17) |
+| `PULSECOUNT?` | Read-only | Low pulse count on GP13 (board pin 17) |
 
 Note that each of the above fields has a maximum length of 63. Each field is 64
 bytes, but is null-terminated. Values longer than 63 bytes will be truncated.
@@ -65,7 +70,7 @@ There are some additional commands:
 |---|---|
 | `CLEAR` | Clear all writable fields |
 | `CHECK?` | Check that the data stored in EEPROM matches the stored checksum, then return either `OK` or `ERR` |
-| `RESETCOUNT` | Reset the edge count to 0 |
+| `RESETCOUNT` | Reset the pulse count to 0 |
 
 ## Build Requirements
 
@@ -91,6 +96,10 @@ This step may take quite some time, as it will download the Pi Pico SDK. If you
 wish to use USB for serial communications instead of UART, add `-DUSB_SERIAL=ON`
 to the above command.
 
+The default minimum pulse width is 100ms. To override this time limit, pass
+`-DMIN_PULSE_WIDTH_US=500000` to get 500ms (you can use any whole number of
+microseconds greater than or equal to 10, however).
+
 After the configuration step is done, you can build the project like so:
 
 ```

src/main.cpp

@@ -35,8 +35,18 @@
 
 #define I2C_INST i2c0
 
+// How long a low pulse must be to be counted.
+#ifdef CONFIG_MIN_PULSE_WIDTH_US
+#define MIN_PULSE_WIDTH_US (int64_t(CONFIG_MIN_PULSE_WIDTH_US))
+#else
+#define MIN_PULSE_WIDTH_US (100'000ULL)
+#endif  // CONFIG_MIN_PULSE_WIDTH_US
+
+static_assert(MIN_PULSE_WIDTH_US >= 10ULL,
+              "Minimum pulse width must be at least 10us!");
+
 static constexpr std::uint32_t kDeviceInfoAddr{0x0};
-static constexpr std::uint32_t kEdgeCountAddr{0x800};
+static constexpr std::uint32_t kPulseCountAddr{0x800};
 
 // Board ID (this is set only once and stored here).
 static char board_id[PICO_UNIQUE_BOARD_ID_SIZE_BYTES * 2 + 1];
@@ -47,9 +57,8 @@ static DeviceInfoBlock data;
 // EEPROM peripheral.
 static AT24CM02 eeprom{I2C_INST, true};
 
-static volatile std::uint32_t edgecount;
-static std::uint32_t last_edgecount;
-static volatile ::absolute_time_t last_edge_time;
+static volatile std::uint32_t pulsecount;
+static std::uint32_t last_pulsecount;
 
 [[noreturn]] static void Panic() noexcept {
   while (1) {
@@ -82,20 +91,20 @@ static void ValidateDeviceInfo() noexcept {
   }
 }
 
-static void StoreEdgeCount(std::uint32_t ec) noexcept {
-  if (!eeprom.Write(kEdgeCountAddr, reinterpret_cast<const std::uint8_t*>(&ec),
-                    sizeof(ec))) {
+static void StorePulseCount(std::uint32_t pc) noexcept {
+  if (!eeprom.Write(kPulseCountAddr, reinterpret_cast<const std::uint8_t*>(&pc),
+                    sizeof(pc))) {
     Panic();
   }
 }
 
-static void LoadEdgeCount() noexcept {
-  std::uint32_t ec;
-  if (!eeprom.Read(kEdgeCountAddr, reinterpret_cast<std::uint8_t*>(&ec),
-                   sizeof(ec))) {
+static void LoadPulseCount() noexcept {
+  std::uint32_t pc;
+  if (!eeprom.Read(kPulseCountAddr, reinterpret_cast<std::uint8_t*>(&pc),
+                   sizeof(pc))) {
     Panic();
   }
-  edgecount = ec;
+  pulsecount = pc;
 }
 
 [[nodiscard]] static bool WriteLockEnabled() noexcept {
@@ -147,8 +156,8 @@ static void HandleSerialMessage(std::string_view message) noexcept {
         } else {
           std::printf("ERR\n");
         }
-      } else if (header == "EDGECOUNT"sv) {
-        std::printf("%u\n", edgecount);
+      } else if (header == "PULSECOUNT"sv) {
+        std::printf("%u\n", pulsecount);
       }
     }
   } else {
@@ -159,9 +168,9 @@ static void HandleSerialMessage(std::string_view message) noexcept {
         StoreDeviceInfo();
       }
     } else if (header == "RESETCOUNT"sv) {
-      StoreEdgeCount(0);
-      edgecount = 0;
-      last_edgecount = 0;
+      StorePulseCount(0);
+      pulsecount = 0;
+      last_pulsecount = 0;
     }
   }
 }
@@ -203,28 +212,37 @@ int main(void) {
   LoadDeviceInfo();
   ValidateDeviceInfo();
 
-  LoadEdgeCount();
+  LoadPulseCount();
   // check for blank EEPROM
-  if (edgecount == 0xFFFFFFFF) {
-    edgecount = 0;
-    StoreEdgeCount(0);
+  if (pulsecount == 0xFFFFFFFF) {
+    pulsecount = 0;
+    StorePulseCount(0);
   }
 
   // Get the board ID (we only need to do this once)
   ::pico_get_unique_board_id_string(board_id, sizeof(board_id));
 
-  last_edgecount = edgecount;
-  last_edge_time = ::get_absolute_time();
+  last_pulsecount = pulsecount;
+  static volatile ::absolute_time_t falling_edge_time = ::get_absolute_time();
+  static volatile bool pulse_started = false;
 
-  // Falling edges increase the edge count.
+  // When we see a falling edge, store the time that happened. When we see
+  // a rising edge, see how long the pulse was, and if it was long enough,
+  // increment the edge count. Else, we wait for the next falling edge.
   ::gpio_set_irq_enabled_with_callback(
-      PIN_SWITCH, GPIO_IRQ_EDGE_FALL, true, [](::uint, std::uint32_t) {
+      PIN_SWITCH, GPIO_IRQ_EDGE_FALL | GPIO_IRQ_EDGE_RISE, true,
+      [](::uint, std::uint32_t event_mask) {
         const auto now = ::get_absolute_time();
-        const auto diff = ::absolute_time_diff_us(last_edge_time, now);
-        // 50ms debounce
-        if (diff >= 50'000) {
-          last_edge_time = now;
-          edgecount = edgecount + 1;
+        if (!pulse_started && (event_mask & GPIO_IRQ_EDGE_FALL)) {
+          pulse_started = true;
+          falling_edge_time = now;
+        } else if (pulse_started && (event_mask & GPIO_IRQ_EDGE_RISE)) {
+          const auto diff = ::absolute_time_diff_us(falling_edge_time, now);
+          // Look for low pulses wide enough to be counted.
+          if (diff >= MIN_PULSE_WIDTH_US) {
+            pulse_started = false;
+            pulsecount = pulsecount + 1;
+          }
         }
       });
 
@@ -234,8 +252,8 @@ int main(void) {
   while (1) {
     c = ::getchar_timeout_us(10);
     if (c == PICO_ERROR_TIMEOUT) {
-      if (edgecount != last_edgecount) {
-        StoreEdgeCount(last_edgecount = edgecount);
+      if (pulsecount != last_pulsecount) {
+        StorePulseCount(last_pulsecount = pulsecount);
       }
       continue;
     }