Add INT pin hardware verification to spectral interrupt test

- Verify physical INT pin goes LOW when interrupt fires
- Verify INT pin returns HIGH after clearStatus()
- Tests both high and low threshold crossing
- INT pin connected to Arduino D2 (active low)

Author: clawpi

hw_tests/10_spectral_interrupt_test/10_spectral_interrupt_test.ino

@@ -6,36 +6,41 @@
  * - Self-calibrating thresholds based on ambient conditions
  * - High threshold crossing detection
  * - Low threshold crossing detection
- * - Status register polling (INT pin not required)
+ * - Status register AINT bit verification
+ * - Physical INT pin verification (active low)
  *
  * Hardware: AS7343 on I2C, NeoPixel ring (16 LEDs) on pin 6
+ *           AS7343 INT pin connected to Arduino pin 2
+ * Board: Metro Mini (arduino:avr:uno)
  */
 
 #include <Adafruit_AS7343.h>
 #include <Adafruit_NeoPixel.h>
 
 #define NEOPIXEL_PIN 6
 #define NEOPIXEL_COUNT 16
+#define INT_PIN 2 // AS7343 INT pin connected here (active low)
 
 Adafruit_AS7343 as7343;
 Adafruit_NeoPixel pixels(NEOPIXEL_COUNT, NEOPIXEL_PIN, NEO_GRB + NEO_KHZ800);
 
 uint16_t allChannels[18];
+bool statusTestPass = true;
+bool intPinTestPass = true;
 
 // Helper to wait for data ready with timeout
 bool waitForData(uint16_t timeoutMs = 2000) {
   uint32_t start = millis();
   while (!as7343.dataReady()) {
-    if (millis() - start > timeoutMs) {
+    if (millis() - start > timeoutMs)
       return false;
-    }
     delay(10);
   }
   return true;
 }
 
-// Take a measurement and return FZ channel value
-uint16_t measureFZ() {
+// Take a measurement and return CH0 value
+uint16_t measureCH0() {
   as7343.stopMeasurement();
   delay(10);
   as7343.clearStatus();
@@ -47,7 +52,7 @@ uint16_t measureFZ() {
   }
 
   as7343.readAllChannels(allChannels);
-  return allChannels[AS7343_CHANNEL_FZ];
+  return allChannels[0]; // CH0 in 6-channel mode
 }
 
 void setup() {
@@ -57,8 +62,12 @@ void setup() {
 
   Serial.println(F("AS7343 Spectral Interrupt Test"));
   Serial.println(F("=============================="));
+  Serial.println(F("INT pin: D2 (active low)"));
   Serial.println();
 
+  // Initialize INT pin as input with pull-up
+  pinMode(INT_PIN, INPUT_PULLUP);
+
   // Initialize NeoPixels
   pixels.begin();
   pixels.clear();
@@ -72,183 +81,225 @@ void setup() {
       delay(100);
   }
 
-  // Use low gain to avoid saturation
-  as7343.setGain(AS7343_GAIN_16X);
-  as7343.setATIME(29);   // 30 cycles
-  as7343.setASTEP(599);  // ~1.67ms step -> ~50ms total
-
-  // Set threshold channel to 0 (FZ)
-  as7343.setThresholdChannel(0);
+  // Use 6-channel mode, low gain
+  as7343.setSMUXMode(AS7343_SMUX_6CH);
+  as7343.setGain(AS7343_GAIN_4X);
+  as7343.setATIME(29);
+  as7343.setASTEP(599);
 
   // =====================
-  // CALIBRATION PHASE
+  // CALIBRATION
   // =====================
-  Serial.println(F("CALIBRATION:"));
+  Serial.println(F("Calibration:"));
 
   // Baseline: NeoPixels OFF
   pixels.clear();
   pixels.show();
   delay(100);
 
-  uint16_t baseline = measureFZ();
-  Serial.print(F("  NeoPixels OFF baseline (FZ): "));
+  uint16_t baseline = measureCH0();
+  Serial.print(F("  NeoPixels OFF (CH0): "));
   Serial.println(baseline);
 
-  // Peak: NeoPixels ON bright
+  // Peak: NeoPixels ON
   for (int i = 0; i < NEOPIXEL_COUNT; i++) {
-    pixels.setPixelColor(i, pixels.Color(255, 255, 255));
+    pixels.setPixelColor(i, 0, 0, 255); // Blue
   }
   pixels.show();
   delay(100);
 
-  uint16_t peak = measureFZ();
-  Serial.print(F("  NeoPixels ON peak (FZ): "));
+  uint16_t peak = measureCH0();
+  Serial.print(F("  NeoPixels ON  (CH0): "));
   Serial.println(peak);
 
   // Calculate thresholds
   uint16_t range = peak - baseline;
-  uint16_t lowThresh = baseline + (range / 4);       // 25% of range
-  uint16_t highThresh = baseline + (3 * range / 4);  // 75% of range
+  uint16_t lowThresh = baseline + (range / 4);
+  uint16_t highThresh = baseline + (3 * range / 4);
 
-  Serial.print(F("  Calculated thresholds: low="));
-  Serial.print(lowThresh);
-  Serial.print(F(" high="));
+  Serial.print(F("  Low threshold:  "));
+  Serial.println(lowThresh);
+  Serial.print(F("  High threshold: "));
   Serial.println(highThresh);
   Serial.println();
 
-  // Turn off NeoPixels
-  pixels.clear();
-  pixels.show();
-
   // =====================
-  // INTERRUPT SETUP
+  // SETUP INTERRUPTS
   // =====================
-  Serial.println(F("INTERRUPT TEST:"));
-
-  // Set thresholds
   as7343.setLowThreshold(lowThresh);
   as7343.setHighThreshold(highThresh);
+  as7343.setPersistence(0); // Immediate
+  as7343.setThresholdChannel(0);
 
-  // Verify readback
-  uint16_t readLow = as7343.getLowThreshold();
-  uint16_t readHigh = as7343.getHighThreshold();
-
-  Serial.print(F("  Thresholds set: low="));
-  Serial.print(readLow);
-  Serial.print(F(" high="));
-  Serial.println(readHigh);
+  // Clear any pending interrupts
+  as7343.clearStatus();
+  delay(10);
 
-  // Set persistence to 1 (trigger after 1 consecutive reading)
-  as7343.setPersistence(1);
-  Serial.print(F("  Persistence: "));
-  Serial.println(as7343.getPersistence());
+  // Check INT pin is HIGH (no interrupt) after clear
+  bool intPinIdle = digitalRead(INT_PIN);
+  Serial.print(F("INT pin after clear: "));
+  Serial.println(intPinIdle ? F("HIGH (good)") : F("LOW (unexpected)"));
+  if (!intPinIdle) {
+    Serial.println(F("  Warning: INT pin stuck low"));
+  }
   Serial.println();
 
   // Enable spectral interrupt
   as7343.enableSpectralInterrupt(true);
 
-  bool highTestPass = false;
-  bool lowTestPass = false;
-
   // =====================
   // HIGH THRESHOLD TEST
   // =====================
-  Serial.println(F("High threshold test:"));
+  Serial.println(F("High threshold test (NeoPixels ON):"));
 
-  // Turn NeoPixels ON bright
+  // NeoPixels ON
   for (int i = 0; i < NEOPIXEL_COUNT; i++) {
-    pixels.setPixelColor(i, pixels.Color(255, 255, 255));
+    pixels.setPixelColor(i, 0, 0, 255);
   }
   pixels.show();
-  delay(100);
+  delay(50);
 
-  // Clear status and start measurement
+  // Start measurement, prime pipeline, then check
   as7343.clearStatus();
   as7343.startMeasurement();
 
+  // First cycle - prime
   if (!waitForData()) {
-    Serial.println(F("  ERROR: Measurement timeout"));
+    Serial.println(F("  ERROR: Timeout"));
+    statusTestPass = false;
+  }
+  as7343.readAllChannels(allChannels);
+  as7343.clearStatus();
+
+  // Second cycle - actual test
+  if (!waitForData()) {
+    Serial.println(F("  ERROR: Timeout"));
+    statusTestPass = false;
   } else {
     as7343.readAllChannels(allChannels);
-    uint16_t reading = allChannels[AS7343_CHANNEL_FZ];
+    uint16_t reading = allChannels[0];
 
-    // Check status for AINT bit (bit 3 = 0x08)
     uint8_t status = as7343.getStatus();
     bool aintSet = (status & 0x08) != 0;
-
-    Serial.print(F("  NeoPixels ON, reading: "));
-    Serial.println(reading);
-    Serial.print(F("  Status: 0x"));
-    if (status < 0x10) Serial.print(F("0"));
-    Serial.print(status, HEX);
-    Serial.print(F(", AINT bit: "));
-    Serial.println(aintSet ? F("SET") : F("CLEAR"));
-
-    // Should trigger because reading > highThresh
-    highTestPass = aintSet && (reading > highThresh);
-
-    Serial.print(F("  Result: "));
-    Serial.println(highTestPass ? F("PASS") : F("FAIL"));
+    bool intPinLow = !digitalRead(INT_PIN);
+
+    Serial.print(F("  CH0 reading: "));
+    Serial.print(reading);
+    Serial.print(F(" (threshold: "));
+    Serial.print(highThresh);
+    Serial.println(F(")"));
+
+    Serial.print(F("  Status AINT: "));
+    Serial.print(aintSet ? F("SET") : F("CLEAR"));
+    bool statusOK = aintSet && (reading > highThresh);
+    Serial.println(statusOK ? F(" PASS") : F(" FAIL"));
+    if (!statusOK)
+      statusTestPass = false;
+
+    Serial.print(F("  INT pin:     "));
+    Serial.print(intPinLow ? F("LOW (active)") : F("HIGH"));
+    Serial.println(intPinLow ? F(" PASS") : F(" FAIL"));
+    if (!intPinLow)
+      intPinTestPass = false;
+
+    // Verify clear works
+    as7343.clearStatus();
+    delay(5);
+    bool intPinAfterClear = digitalRead(INT_PIN);
+    Serial.print(F("  After clear: "));
+    Serial.print(intPinAfterClear ? F("HIGH") : F("LOW"));
+    Serial.println(intPinAfterClear ? F(" PASS") : F(" FAIL"));
+    if (!intPinAfterClear)
+      intPinTestPass = false;
   }
+
+  as7343.stopMeasurement();
   Serial.println();
 
   // =====================
   // LOW THRESHOLD TEST
   // =====================
-  Serial.println(F("Low threshold test:"));
+  Serial.println(F("Low threshold test (NeoPixels OFF):"));
 
-  // Turn NeoPixels OFF
+  // NeoPixels OFF
   pixels.clear();
   pixels.show();
-  delay(100);
+  delay(50);
 
-  // Clear status and start measurement
+  // Start measurement, prime pipeline, then check
   as7343.clearStatus();
   as7343.startMeasurement();
 
+  // First cycle - prime
   if (!waitForData()) {
-    Serial.println(F("  ERROR: Measurement timeout"));
+    Serial.println(F("  ERROR: Timeout"));
+    statusTestPass = false;
+  }
+  as7343.readAllChannels(allChannels);
+  as7343.clearStatus();
+
+  // Second cycle - actual test
+  if (!waitForData()) {
+    Serial.println(F("  ERROR: Timeout"));
+    statusTestPass = false;
   } else {
     as7343.readAllChannels(allChannels);
-    uint16_t reading = allChannels[AS7343_CHANNEL_FZ];
+    uint16_t reading = allChannels[0];
 
-    // Check status for AINT bit (bit 3 = 0x08)
     uint8_t status = as7343.getStatus();
     bool aintSet = (status & 0x08) != 0;
-
-    Serial.print(F("  NeoPixels OFF, reading: "));
-    Serial.println(reading);
-    Serial.print(F("  Status: 0x"));
-    if (status < 0x10) Serial.print(F("0"));
-    Serial.print(status, HEX);
-    Serial.print(F(", AINT bit: "));
-    Serial.println(aintSet ? F("SET") : F("CLEAR"));
-
-    // Should trigger because reading < lowThresh
-    lowTestPass = aintSet && (reading < lowThresh);
-
-    Serial.print(F("  Result: "));
-    Serial.println(lowTestPass ? F("PASS") : F("FAIL"));
+    bool intPinLow = !digitalRead(INT_PIN);
+
+    Serial.print(F("  CH0 reading: "));
+    Serial.print(reading);
+    Serial.print(F(" (threshold: "));
+    Serial.print(lowThresh);
+    Serial.println(F(")"));
+
+    Serial.print(F("  Status AINT: "));
+    Serial.print(aintSet ? F("SET") : F("CLEAR"));
+    bool statusOK = aintSet && (reading < lowThresh);
+    Serial.println(statusOK ? F(" PASS") : F(" FAIL"));
+    if (!statusOK)
+      statusTestPass = false;
+
+    Serial.print(F("  INT pin:     "));
+    Serial.print(intPinLow ? F("LOW (active)") : F("HIGH"));
+    Serial.println(intPinLow ? F(" PASS") : F(" FAIL"));
+    if (!intPinLow)
+      intPinTestPass = false;
+
+    // Verify clear works
+    as7343.clearStatus();
+    delay(5);
+    bool intPinAfterClear = digitalRead(INT_PIN);
+    Serial.print(F("  After clear: "));
+    Serial.print(intPinAfterClear ? F("HIGH") : F("LOW"));
+    Serial.println(intPinAfterClear ? F(" PASS") : F(" FAIL"));
+    if (!intPinAfterClear)
+      intPinTestPass = false;
   }
+
+  as7343.stopMeasurement();
   Serial.println();
 
   // =====================
-  // FINAL RESULT
+  // SUMMARY
   // =====================
-
-  // Cleanup
   as7343.enableSpectralInterrupt(false);
-  as7343.stopMeasurement();
   pixels.clear();
   pixels.show();
 
-  // At least one interrupt must fire for pass
-  bool pass = (highTestPass || lowTestPass);
+  Serial.println(F("Summary:"));
+  Serial.print(F("  Status register: "));
+  Serial.println(statusTestPass ? F("PASS") : F("FAIL"));
+  Serial.print(F("  INT pin:         "));
+  Serial.println(intPinTestPass ? F("PASS") : F("FAIL"));
 
+  bool allPass = statusTestPass && intPinTestPass;
+  Serial.println();
   Serial.print(F("RESULT: "));
-  Serial.println(pass ? F("PASS") : F("FAIL"));
+  Serial.println(allPass ? F("PASS") : F("FAIL"));
 }
 
-void loop() {
-  // Nothing to do
-}
+void loop() { delay(1000); }