GPIO IRQs, FreeRTOS, and LWIP

[jaguilar]

Friends, I have a sketch where I want to listen for some interrupts and increment counters when they fire. Then, some computation is done on these counters periodically and the results are sent off to an MQTT server.

What I've found is that something about starting up the MQTT client disables my interrupts. I've not been able to drill down into the exact source of the problem, but what I can tell you is that until I see the "connected" message in this sketch, I can click my button and see "interrupted!" on Serial1. After the mqtt client is connected, no joy.

#include <Arduino.h>
#include <FreeRTOS.h>
#include <HADevice.h>
#include <HAMqtt.h>
#include <WiFi.h>
#include <device-types/HASensor.h>
#include <semphr.h>
#include <task.h>
#include <timers.h>

#include <array>
#include <atomic>
#include <cmath>
#include <functional>
#include <string_view>
#include <utility>

constexpr auto kWindDirectionPin = A0;

std::string_view windvane_level_to_direction(int32_t adc_reading) {
  // ADC target levels assume a divider impedance of 3377 ohms, which can be
  // achieved by putting a 5100 ohm and 10000 ohm resistor in parallel.
  constexpr std::array<std::pair<std::string_view, int32_t>, 16> adc_targets{
      // New: I have the divider, then the ADC, then the windvane, then ground.
      {std::make_pair("NE", 2901), std::make_pair("E", 936),
       std::make_pair("SE", 1616), std::make_pair("S", 2195),
       std::make_pair("SW", 3382), std::make_pair("W", 3984),
       std::make_pair("NW", 3893), std::make_pair("N", 3716),
       std::make_pair("NNE", 2705), std::make_pair("ENE", 855),
       std::make_pair("ESE", 693), std::make_pair("SSE", 1204),
       std::make_pair("SSW", 1972), std::make_pair("WSW", 3305),
       std::make_pair("WNW", 3792), std::make_pair("NNW", 3548)}};
  int min_diff = std::numeric_limits<int>::max();
  int min_index = -1;
  for (int i = 0; i < adc_targets.size(); ++i) {
    const int diff = std::abs(adc_targets[i].second - adc_reading);
    if (min_diff > diff) {
      min_diff = diff;
      min_index = i;
    }
  }
  return adc_targets[min_index].first;
}

HASensor ha_windvane("weatherstation_anemometer");

void sample_windvane(TimerHandle_t) {
  const uint16_t wind_voltage = analogRead(kWindDirectionPin);
  const std::string_view direction = windvane_level_to_direction(wind_voltage);
  ha_windvane.setValue(direction.data());
  ha_windvane.setDeviceClass("enum");
  Serial1.printf("Publishing: %s: %s\n", ha_windvane.getName(),
                 direction.data());
}

void SetupWindvane() {
  ha_windvane.setName("Windvane");
  ha_windvane.setDeviceClass("enum");
  analogReadResolution(12);

  xTimerStart(xTimerCreate("windvane_reporter", pdMS_TO_TICKS(4997), true,
                           nullptr, sample_windvane),
              portMAX_DELAY);
}

// A rate limited counter. It can be incremented at most once per update_period.
// If an increment is received in less time than the update period from the
// previous, it is a noop. This counter is not thread safe, so anything that
// is flushing the counter needs to ensure that the counter is not being
// incremented at the same time.
struct RateLimitedCounter {
  const int32_t update_period;
  uint32_t next_update = 0;
  int32_t count = 0;

  void Inc() {
    const uint32_t now = millis();
    if (static_cast<int32_t>(next_update - now) > 0) return;
    ++count;
    next_update = now + update_period;
  }

  // Sets the counter value to zero and returns the current value.
  int32_t Flush() { return std::exchange(count, 0); }
};

// Counts each time a pin goes low, subject to a maximum rate. Multiplies
// the count by a scale and reports it to an HASensor periodically.
class ScaledSamplePinCounter {
 public:
  static constexpr int32_t CalcCounterUpdatePeriodMs(float scale,
                                                     float max_value,
                                                     float period_length_s) {
    const float max_units_per_s = max_value / period_length_s;
    const float max_ticks_per_s = scale * max_units_per_s;
    return 1000 / max_ticks_per_s;
  }

  ScaledSamplePinCounter(int pin, float scale, float max_value, float period_s,
                         HASensor& destination)
      : pin_(pin),
        scale_(scale),
        period_s_(period_s),
        counter_{.update_period =
                     CalcCounterUpdatePeriodMs(scale, max_value, period_s)},
        dest_(destination) {}

  ~ScaledSamplePinCounter() {
    Serial1.print("Destroying counter\n");
    xTimerDelete(flush_timer_, portMAX_DELAY);
    detachInterrupt(pin_);
  }

  void begin() {
    // Each time the pin goes low, increment the counter. The counter
    // naturally debounces due to the maximum update frequency.
    pinMode(pin_, INPUT_PULLUP);

    Serial1.printf("attaching interrupted to %d\n", pin_);
    attachInterruptParam(
        pin_,
        +[](void* counter) {
          Serial1.print("interrupt!\n");
          // reinterpret_cast<RateLimitedCounter*>(counter)->Inc();
        },
        FALLING, &counter_);

    // Schedule a timer to update the sensor's value with the counter's value.
    flush_timer_ = xTimerCreate(
        "counter_flusher", pdMS_TO_TICKS(period_s_ * 1000), true, this,
        +[](TimerHandle_t timer) {
          reinterpret_cast<ScaledSamplePinCounter*>(pvTimerGetTimerID(timer))
              ->FlushCounterValueToSensor();
        });
    xTimerStart(flush_timer_, portMAX_DELAY);
  }

  void FlushCounterValueToSensor() {
    int32_t ticks;
    taskENTER_CRITICAL();
    ticks = counter_.Flush();
    taskEXIT_CRITICAL();
    const float value = ticks * scale_;
    char buffer[32];
    configASSERT(snprintf(buffer, sizeof(buffer), "%.3f", value) < 32);
    dest_.setValue(buffer);
    Serial1.printf("Publishing: %s: %0.3f\n", dest_.getName(), value);
  }

  const int pin_;
  const float scale_;
  const float period_s_;
  RateLimitedCounter counter_;
  TimerHandle_t flush_timer_;
  HASensor& dest_;
};

HASensor anemometer("anemometer");

constexpr int kWindPin = 14;
// I.e. if the anemometer ticks once per second then the windspeed is 1.73
// mph. We (falsely) assume a linear relationship between ticks and speed,
// and therefore compute the average simply by scaling the speed down by the
// number of seconds over which we're reporting.
constexpr float kWindSpeedPerTickPerSecond = 1.73;  // mph
constexpr float kWindReportPeriodS = 5;
constexpr float kWindScale = kWindSpeedPerTickPerSecond / kWindReportPeriodS;
constexpr float kWindMaxSpeed = 100;

ScaledSamplePinCounter wind_counter(kWindPin, kWindScale, kWindMaxSpeed,
                                    kWindReportPeriodS, anemometer);

void SetupAnemometer() {
  anemometer.setName("Anemometer");
  anemometer.setUnitOfMeasurement("mph");
  anemometer.setDeviceClass("wind_speed");
  anemometer.setStateClass("measurement");
  anemometer.setForceUpdate(true);
  wind_counter.begin();
}

HASensor rain_sensor("rain_gauge");

// In the case of the rain gauge, the total amount of rain is simply the
// number of times the gauge has ticked.
constexpr int kRainPin = 15;
constexpr float kRainSpeedPerTickPerSecond = 0.011;  // inches of rain
constexpr float kRainReportPeriodS =
    15;  // TODO: jaguilar - This should report every 15 mins rather than
         // seconds, but this is just for testing.
constexpr float kRainScale = 1.;
// We will limit our report rate to 6 inches per hour for any one period.
constexpr float kRainMaxValue = 6. / 4;

ScaledSamplePinCounter rain_counter(kRainPin, kRainScale, kRainMaxValue,
                                    kRainReportPeriodS, rain_sensor);

void SetupRainGauge() {
  rain_sensor.setName("Rainfall");
  rain_sensor.setUnitOfMeasurement("in");
  rain_sensor.setDeviceClass("precipitation");
  rain_sensor.setStateClass("total_increasing");
  rain_sensor.setForceUpdate(true);
  rain_counter.begin();
}

#define SSTR(s) (#s)
#define STR(s) SSTR(s)

WiFiClient client;
HADevice ha_device("jagspico_weatherstation");
HAMqtt mqtt(client, ha_device);

void setup() {
  ha_device.setName("weatherstation");

  Serial1.begin();

  Serial1.println("Set up interrupt");
  delay(2000);

  Serial1.println("WiFi.setHostname");
  WiFi.setHostname("weatherstation");

  delay(2000);

  Serial1.println("WiFi.begin");
  WiFi.begin(STR(WIFI_SSID), STR(WIFI_PASSWORD));

  delay(2000);

  while (WiFi.status() != WL_CONNECTED) {
    Serial1.printf("Waiting for connection to %s\n", STR(WIFI_SSID));
    delay(1000);
  }

  Serial1.println("WiFi ready");

  delay(2000);

  SetupWindvane();
  delay(3);
  SetupRainGauge();
  delay(3);
  SetupAnemometer();

  Serial.println("All sensors up");

  delay(2000);

  // mqtt.begin(STR(MQTT_HOSTNAME), STR(MQTT_USER), STR(MQTT_PASSWORD));
  mqtt.begin(IPAddress(192, 168, 4, 196), STR(MQTT_USER), STR(MQTT_PASSWORD));
  Serial1.println("mqtt.begin");

  delay(2000);

  xTaskCreate(
      [](void*) {
        while (true) {
          mqtt.loop();
          delay(5);
        }
      },
      "mqtt_loop", 1024, nullptr, 1, nullptr);

  while (!mqtt.isConnected()) {
    Serial1.printf("Connection state %d\n", mqtt.getState());
    delay(1000);
  }
  Serial1.printf("Connected\n");
  delay(1000);
};

void loop() { delay(10000); }

My build flags:

	-DPIO_FRAMEWORK_ARDUINO_ENABLE_RTTI
	-fstack-protector
	-std=c++20
	-DconfigTIMER_SERVICE_TASK_CORE_AFFINITY=0b1
	-DconfigUSE_TIMERS=1

I'm going to keep debugging but I'm wondering if this rings a bell for anyone? I can try to put together a more minimal example if this one is too long.

[jaguilar]

Moving

  SetupWindvane();
  SetupRainGauge();
  SetupAnemometer();

To the end of the function makes it work. This suggests that something is clearing the gpio interrupts in the process of setting up the mqtt server, but I have no idea what it could be. WiFi communication continues happily after this change, so nothing is obviously depending on these IRQs besides my code.

[jaguilar]

Rephrased this as issue #2577. Closing the discussion.