PstTestPins.h

Go to the documentation of this file.

#pragma once
 
 #include <Arduino.h>
 #include <SerialIo.h>
 
 #include <CardMri.h>
 #include <LccFusionCore/Adafruit_MCP23017.h>
// Expects a global/static SerialIO named `g_serialIO`
 
class PstTestPins
{
public:
  enum class Type : uint8_t
  {
    IO,        
    Input,     
    Output,    
    OpenDrain, 
    ADC,       
    I2C_SDA,   
    I2C_SCL,   
    PWM,       
    Button,    
    UART_RX,   
    UART_TX,   
    McpInput,  
    Unknown    
  };
 
  PstTestPins() {}
 
  static inline void set_led(uint8_t pin, bool on)
  {
    digitalWrite(pin, on ? LOW : HIGH);
  }
 
  static inline void init_led(uint8_t pin)
  {
    pinMode(pin, OUTPUT);
    set_led(pin, false);
  }
 
  // ------------------------------------------------------------
  // One-call dispatcher
  // ------------------------------------------------------------
  bool testPin(uint8_t pin, Type type, const char *label = nullptr) const
  {
    const char *nm = (label && *label) ? label : "PIN";
    switch (type)
    {
    case Type::IO:
      return _testShorted(pin, nm, /*gentle=*/false) & _testOpen(pin, nm, /*gentle=*/false) & _testDriveRead(pin, nm);
 
    case Type::Input:
      return _testShorted(pin, nm, /*gentle=*/false) & _testOpen(pin, nm, /*gentle=*/false);
 
    case Type::Output:
      return _testShorted(pin, nm, /*gentle=*/false) & _testDriveRead(pin, nm);
 
    case Type::OpenDrain:
      return _testOpenDrain(pin, nm);
 
    case Type::ADC:
      return _testAdc(pin, nm);
 
    case Type::I2C_SDA:
      return _testI2cLineCheck(pin, nm, "SDA");
 
    case Type::I2C_SCL:
      return _testI2cLineCheck(pin, nm, "SCL");
 
    case Type::PWM:
      return _testDriveRead(pin, nm); // minimal sanity (HIGH/LOW)
 
    case Type::UART_RX:
      // UART RX: use gentle mode (avoid PULLDOWN)
      return _testShorted(pin, nm, /*gentle=*/true) & _testOpen(pin, nm, /*gentle=*/true);
 
    case Type::UART_TX:
      return _testUartTx(pin, nm) & _testOpen(pin, nm, /*gentle=*/false);
 
    case Type::Button:
      return _testShorted(pin, nm, /*gentle=*/false) & _testOpen(pin, nm, /*gentle=*/false);
 
    case Type::Unknown:
    default:
      g_serialIO.sprintf(pstTestPinsMri::MSG_UNKNOWN_TYPE, nm, pin);
      return false;
    }
  }
 
  bool testMcpInput(Adafruit_MCP23017 *pMcp, uint8_t mcpPin, const char *name) const
  {
    if (!pMcp)
    {
      g_serialIO.print(pstTestPinsMri::MSG_MCP_WARN);
      return false;
    }
    g_serialIO.sprintf(pstTestPinsMri::MSG_MCP_HDR, name ? name : "MCP_PIN", mcpPin);
 
    // Safe: never drive OLAT; only input + pull-up
    pMcp->pinMode(mcpPin, INPUT);
    pMcp->pullUp(mcpPin, true);
    delay(2);
    int v = pMcp->digitalRead(mcpPin);
 
    if (v == LOW)
    {
      g_serialIO.print(pstTestPinsMri::MSG_MCP_GND); // “wired to GND”
    }
    else
    {
      g_serialIO.print(pstTestPinsMri::MSG_MCP_FLOAT); // “open / floating”
    }
    return true; // informational test
  }
 
  bool testOpen(uint8_t pin, const char *label = nullptr, bool gentle = false) const
  {
    return _testOpen(pin, label ? label : "NET", gentle);
  }
 
  bool testShorted(uint8_t pin, const char *label = nullptr, bool gentle = false) const
  {
    return _testShorted(pin, label ? label : "NET", gentle);
  }
 
private:
  bool _testUartTx(uint8_t pin, const char *label) const
  {
    if (_isInputOnly(pin))
    {
      g_serialIO.sprintf(pstTestPinsMri::MSG_INPUT_ONLY, label ? label : "PIN", pin);
      return false;
    }
    pinMode(pin, OUTPUT);
    digitalWrite(pin, HIGH); // UART idle level
    delay(1);
    return _testShorted(pin, label ? label : "PIN", /*gentle=*/false) & _testDriveRead(pin, label ? label : "PIN");
  }
 
  static bool _isInputOnly(uint8_t pin)
  {
    return (pin >= 34 && pin <= 39);
  }
 
  static bool _hasInternalPulls(uint8_t pin)
  {
    return !_isInputOnly(pin);
  } // 34-39 lack pulls
 
  bool _testOpen(uint8_t pin, const char *name, bool gentle = false) const
  {
    g_serialIO.sprintf(pstTestPinsMri::MSG_OPEN_HDR, name, pin);
 
    if (!_hasInternalPulls(pin))
    {
      g_serialIO.sprintf(pstTestPinsMri::MSG_NO_NUDGE, name, pin);
      return true; // not a failure-we just can't probe here
    }
 
    if (!gentle)
    {
      pinMode(pin, INPUT_PULLUP);
      delay(2);
      int up = digitalRead(pin);
      pinMode(pin, INPUT_PULLDOWN);
      delay(2);
      int dn = digitalRead(pin);
 
      if (up == HIGH && dn == LOW)
      {
        g_serialIO.print(pstTestPinsMri::MSG_OPEN_PASS);
        return true;
      }
      if (up == LOW && dn == LOW)
      {
        g_serialIO.sprintf(pstTestPinsMri::MSG_STUCK_GND, name, pin);
        return false;
      }
      if (up == HIGH && dn == HIGH)
      {
        g_serialIO.sprintf(pstTestPinsMri::MSG_STUCK_VCC, name, pin);
        return false;
      }
      g_serialIO.sprintf(pstTestPinsMri::MSG_OPEN_SUSPECT, name, pin, up, dn);
      return false;
    }
    else
    {
      // Gentle: unbiased read + pull-up only
      pinMode(pin, INPUT);
      delay(2);
      int idle = digitalRead(pin);
      pinMode(pin, INPUT_PULLUP);
      delay(2);
      int up = digitalRead(pin);
      pinMode(pin, INPUT);
 
      if (up == HIGH)
      {
        g_serialIO.print(pstTestPinsMri::MSG_OPEN_PASS);
        return true;
      }
      // If we couldn't lift it HIGH with PULLUP, likely shorted LOW or actively held
      g_serialIO.sprintf(pstTestPinsMri::MSG_OPEN_SUSPECT, name, pin, idle, up);
      return false;
    }
  }
 
  bool _testShorted(uint8_t pin, const char *name, bool gentle = false) const
  {
    g_serialIO.sprintf(pstTestPinsMri::MSG_SHORT_HDR, name, pin);
    if (!_hasInternalPulls(pin))
    {
      g_serialIO.sprintf(pstTestPinsMri::MSG_NO_NUDGE, name, pin);
      return true;
    }
 
    if (!gentle)
    {
      pinMode(pin, INPUT_PULLUP);
      delay(2);
      int up = digitalRead(pin);
      pinMode(pin, INPUT_PULLDOWN);
      delay(2);
      int dn = digitalRead(pin);
      if (up == LOW && dn == LOW)
      {
        g_serialIO.sprintf(pstTestPinsMri::MSG_STUCK_GND, name, pin);
        return false;
      }
      if (up == HIGH && dn == HIGH)
      {
        g_serialIO.sprintf(pstTestPinsMri::MSG_STUCK_VCC, name, pin);
        return false;
      }
      g_serialIO.print(pstTestPinsMri::MSG_SHORT_PASS);
      return true;
    }
    else
    {
      // Gentle: never assert LOW (no PULLDOWN)
      pinMode(pin, INPUT);
      delay(2);
      int idle = digitalRead(pin);
      pinMode(pin, INPUT_PULLUP);
      delay(2);
      int up = digitalRead(pin);
      pinMode(pin, INPUT);
 
      if (up == HIGH)
      {
        g_serialIO.print(pstTestPinsMri::MSG_SHORT_PASS);
        return true;
      }
      g_serialIO.sprintf(pstTestPinsMri::MSG_STUCK_GND, name, pin);
      return false;
    }
  }
 
  bool _testDriveRead(uint8_t pin, const char *name) const
  {
    if (_isInputOnly(pin))
    {
      g_serialIO.sprintf(pstTestPinsMri::MSG_INPUT_ONLY, name, pin);
      return false;
    }
    g_serialIO.sprintf(pstTestPinsMri::MSG_DRIVE_HDR, name, pin);
    pinMode(pin, OUTPUT);
    delay(1);
    digitalWrite(pin, HIGH);
    delay(3);
    int rH = digitalRead(pin);
    digitalWrite(pin, LOW);
    delay(3);
    int rL = digitalRead(pin);
 
    if (rH == HIGH && rL == LOW)
    {
      g_serialIO.print(pstTestPinsMri::MSG_DRIVE_PASS);
      return true;
    }
    g_serialIO.sprintf(pstTestPinsMri::MSG_DRIVE_FAIL, name, pin, rH, rL);
    return false;
  }
 
  bool _testOpenDrain(uint8_t pin, const char *name) const
  {
    if (_isInputOnly(pin))
    {
      g_serialIO.sprintf(pstTestPinsMri::MSG_INPUT_ONLY, name, pin);
      return false;
    }
    g_serialIO.sprintf(pstTestPinsMri::MSG_OD_HDR, name, pin);
    // Drive LOW should read LOW
    pinMode(pin, OUTPUT);
    digitalWrite(pin, LOW);
    delay(3);
    int low = digitalRead(pin);
    // Release (input pull-up) should read HIGH
    pinMode(pin, INPUT_PULLUP);
    delay(3);
    int hi = digitalRead(pin);
    if (low == LOW && hi == HIGH)
    {
      g_serialIO.print(pstTestPinsMri::MSG_OD_PASS);
      return true;
    }
    g_serialIO.sprintf(pstTestPinsMri::MSG_OD_FAIL, name, pin, low, hi);
    return false;
  }
 
  bool _testAdc(uint8_t pin, const char *name) const
  {
    g_serialIO.sprintf(pstTestPinsMri::MSG_ADC_HDR, name, pin);
    analogSetPinAttenuation(pin, ADC_11db); // good up to ~3.3V
    const int N = 8;
    int sumMv = 0;
    for (int i = 0; i < N; ++i)
    {
      sumMv += analogReadMilliVolts(pin);
      delay(2);
    }
    int mv = sumMv / N;
    g_serialIO.sprintf(pstTestPinsMri::MSG_ADC_INFO, name, pin, mv);
    if (mv < 50)
    {
      g_serialIO.print(pstTestPinsMri::MSG_ADC_SHORT_TO_GND_WARN);
      return false;
    }
    if (mv > 3250)
    {
      g_serialIO.print(pstTestPinsMri::MSG_ADC_SHORT_TO_3V3_WARN);
      return false;
    }
    return true;
  }
 
  bool _testI2cLineCheck(uint8_t pin, const char *name, const char *lineName) const
  {
    g_serialIO.sprintf(pstTestPinsMri::MSG_I2C_LINE_HDR, lineName, name, pin);
 
    // Look at bus state without our own pulls
    pinMode(pin, INPUT);
    delay(2);
    int idle = digitalRead(pin);
 
    if (idle == HIGH)
    {
      g_serialIO.sprintf(pstTestPinsMri::MSG_I2C_PULLUP_PASS, lineName);
      return true;
    }
 
    // Gentle nudge to diagnose "missing pull-ups” vs "stuck low”
    pinMode(pin, INPUT_PULLUP);
    delay(2);
    int nudged = digitalRead(pin);
    pinMode(pin, INPUT); // restore neutral
    if (nudged == HIGH)
    {
      g_serialIO.sprintf(pstTestPinsMri::MSG_I2C_MISSING_PULLUP_FAIL, lineName);
      return false;
    }
    else
    {
      g_serialIO.sprintf(pstTestPinsMri::MSG_I2C_SHORT_TO_GROUND_FAIL, lineName);
      return false;
    }
  }
};
 // end of group