问监控电压超过10秒

EN

// **********************************
// shaker motor related definitions

enum class shaker_state : char
{
    motor_off, 
    time_low_voltage,
    motor_on,
};

struct shaker_data_t
{
    shaker_state state;
    unsigned int timestamp;

    // you could add here a small buffer to hold a few previous values
    // of ADC readings to do a bit of filtering...  The median of 5 filter 
    // should work very well here.  It is not absolutely needed for now, 
    // but you should consider having some kind of filter.  The motor may 
    // introduce noise in the readings. We'll just keep the last reading for
    // now.

    unsigned int adc_value;
};

// constants are declared constexpr to save memory space.
constexpr unsigned int SHAKER_TIMEOUT_LOW_VOLTAGE = 8000;  // in milliseconds
constexpr unsigned int SHAKER_TIMEOUT_MOTOR_ON    = 3000;  // .idem. 

// Again to save memory, and allow for DAC related constants
// to be computed at compile-time.  
constexpr inline float adc_value_to_volts(unsigned int value)
{
    return value * (5.f / 1024.f);
}

constexpr inline unsigned int volts_to_adc_value(float tension)
{
    return unsigned int(tension * (1024.f / 5.f));
}

constexpr unsigned int SHAKER_ADC_THRESHOLD = volts_to_adc_value(1.f);

constexpr int SHAKER_MOTOR = 2;
constexpr int SHAKER_ADC   = A0;

// **********************************
// global data

shaker_data_t shaker;

// **********************************

static void shaker_control()
{
  // always read adc.
  shaker.adc_value = analogRead(SHAKER_ADC);

  switch (shaker.state)
  {
  default:           // in case of catastrophic error, turn motor OFF.
  case shaker_state::motor_off:
      digitalWrite(SHAKER_MOTOR, LOW);
      if (shaker.adc_value < SHAKER_ADC_THRESHOLD)
      {
          shaker.state     = shaker_state::time_low_voltage;      
          shaker.timestamp = (unsigned int)millis();
      }
      break;

  case shaker_state::time_low_voltage:
      digitalWrite(SHAKER_MOTOR, LOW);
      if (shaker.adc_value >= SHAKER_ADC_THRESHOLD)
      {
          shaker.state = shaker_state::motor_off;
      }
      else if ((unsigned int)millis() - shaker.timestamp >= SHAKER_TIMEOUT_LOW_VOLTAGE)
      {
          digitalWrite(SHAKER_MOTOR, HIGH);
          shaker.state     = shaker_state::motor_on;
          shaker.timestamp = (unsigned int)millis();
      }
      break;

  case shaker_state::motor_on:
      digitalWrite(SHAKER_MOTOR, HIGH);
      if ((unsigned int)millis() - shaker.timestamp >= SHAKER_TIMEOUT_MOTOR_ON)
      {
          digitalWrite(SHAKER_MOTOR, LOW);
          shaker.state     = shaker_state::motor_off;
          shaker.timestamp = (unsigned int)millis();
      }
      break;
  }
}

// **********************************

void setup() 
{
  Serial.begin(9600);

  digitalWrite(SHAKER_MOTOR, LOW);
  pinMode(SHAKER_MOTOR, OUTPUT);

  shaker.state     = shaker_state::motor_off;
  shaker.timestamp = (unsigned int)millis();
}
    
// **********************************

void loop() 
{
    // get temp and control moror.
    shaker_control();

    // shaker_control is very fast and never blocks, so you have plenty 
    // of extra time to blink LEDs, read switches, etc...
}

class median_of_5_filter
{
  public:
    void push(unsigned int value)
    {
        buffer_[next_] = value;
        if (++next_ >= 5)
            next_ = 0;
        compute();
    }

    unsigned int get() const 
    {
        return filtered_;
    }

  private:
    void compute()
    {
        // bubble sort, but only the first 3 elements

        unsigned int buf_copy[5] = { buffer_[0], buffer_[1], buffer_[2], 
                                     buffer_[3], buffer_[4] };

        for (unsigned char i = 0; i < 3; ++i)
        {
            auto min_index = i;
            auto min_value = buf_copy[i];
            for (unsigned char j = i + 1; j < 5; ++j)
            {
                if (buf_copy[j] < min_value)
                {
                    min_value = buf_copy[j];
                    min_index = j;
                }
            }
            if (i != min_index)
                swap(buf_copy[i], buf_copy[min_index]);
        }
        filtered_ = buf_copy[2];
    }

    static void swap(unsigned int& a, unsigned int& b)
    {
        auto t = a;
        a = b;
        b = t;
    }

  private:
    unsigned int filtered_  = 0;
    unsigned char next_     = 0; 
    unsigned int buffer_[5] = {};
};

struct shaker_data_t
{
    // ...
    median_of_5_filter adc_value;
};

// when reading ADC...
shaker.adc_value.push(analogRead(SHAKER_ADC));

// to get filtered adc reading 
if (shaker.adc_value.get() < SHAKER_ADC_THRESHOLD)