Добавление еще одного датчика расхода в скетч

Ваш код в настоящее время не использует второй датчик потока. Я думаю, у вас есть проблемы в разработке кода, поэтому я стараюсь ходить с вами.

Сначала рассмотрим предпосылки, которые необходимы для двух датчиков потока. Вы уже определили контакты датчиков потока. Вы также определяете количество соответствующих прерываний. На самом деле вам не нужно этого делать. Вы можете легко получить номер прерывания через функцию digitalPinToInterrupt(pin). Таким образом, мы остаемся с определением контакт. Я бы предложил использовать более четкие имена:

int flow_out_pin = 2;
int flow_in_pin = 3;

flow_out означает выход из резервуара, flow_in возвращается в резервуар.

Затем в setup() нам нужно инициировать контакты. У вас есть это

pinMode(sensorPin, INPUT);
digitalWrite(sensorPin, HIGH);

Это может быть затем сделано короче в одной строке на датчик:

pinMode(flow_out_pin, INPUT_PULLUP);
pinMode(flow_in_pin, INPUT_PULLUP);

Теперь прикрепляем прерывания к штифтам:

attachInterrupt(digitalPinToInterrupt(flow_out_pin), flowOutPulseCounter, FALLING);
attachInterrupt(digitalPinToInterrupt(flow_in_pin), flowInPulseCounter, FALLING);

Я использовал указанную функцию, чтобы получить номер прерывания и изменить имя ISR. Вот другой принцип, чем ваш первый предполагаемый способ: я бы позволил датчикам считать в своих собственных ISR и собственных переменных и только вычислять разницу, чтобы отобразить ее. Для этого нам нужно определить наши 2 ISR:

void flowOutPulseCounter()
{
    flowOutPulseCount++;
}
void flowInPulseCounter()
{
    flowInPulseCount++;
}

Переменные count, конечно, должны быть определены (глобально в верхней части скетча):

volatile byte flowOutPulseCount = 0;
volatile byte flowInPulseCount = 0;

Теперь мы оставили код в loop(), Который вычисляет скорость потока, уровень заполнения и т. Д. И Отображает их. Во-первых: При обработке данных прерываний в основном коде вы хотите полностью свести к минимуму время, проведенное с отключенными прерываниями (так как за это время вы можете пропустить импульсы и тем самым ввести ошибки). Обычно вы просто копируете данные в локальные переменные, снова включаете прерывания и выполняете расчет с локальными переменными. Что-то вроде этого (внутри оператора millis() if):

// Отсоединение прерываний
detachInterrupt(digitalPinToInterrupt(flow_out_pin));
detachInterrupt(digitalPinToInterrupt(flow_in_pin));

// copy pulse count variables
byte local_flow_out_count = flowOutPulseCount;
byte local_flow_in_count  = flowInPulseCount;

// сброс переменных счетчика импульсов
flowOutPulseCount = 0;
flowInPulseCount = 0;

// Reattach interrupts
attachInterrupt(digitalPinToInterrupt(flow_out_pin), flowOutPulseCounter, FALLING);
attachInterrupt(digitalPinToInterrupt(flow_in_pin), flowInPulseCounter, FALLING);

// Выполните вычисления с использованием указанных выше локальных переменных и отобразите результаты
...

Для расчетов вы затем рассчитаете расход и общий поток от каждого отсчета импульсов. Затем вы можете рассчитать общий чистый расход и уровень заполнения.

Примечание: Вы можете изменить тип переменной для счетчиков на unsigned int, чтобы получить большую маржу, прежде чем они переполнятся, так как это будет означать неправильные результаты, и вам не повредит использовать его.

Поскольку крисл уже дал очень хороший ответ, я просто добавляю здесь несколько заметок, чтобы дополнить его.

Переменная pulseCount имеет размер всего 8 бит. Он переполнится, если скорость потока превысит 33,7 л/мин. Если существует вероятность того, что фактический поток превышает эту скорость, то, как указано в ответе крисла, вам следует использовать 16-битный счетчик. Если, с другой стороны, вы уверены , что это значение не может быть превышено, то вы можете сохранить 8-битный счетчик и извлечь выгоду из того факта, что доступ к 8-битным значениям является атомарным. Это означает, что вам никогда не нужно отключать прерывания:

// В глобальном масштабе:
byte oldPulseCount;

// Внутри цикла(), один раз в секунду:
byte newPulseCount = pulseCount; // атомарное чтение
byte pulseCountDifference = newPulseCount - oldPulseCount;
oldPulseCount = newPulseCount; // сохранить текущее значение

затем вы вычисляете скорость потока из pulseCountDifference. Обратите внимание, что переполнения pulseCount безвредны, так как разница newPulseCount - oldPulseCount переносит значение по модулю 256 в правильное значение. Обратите внимание также, что pulseCount никогда не сбрасывается, так как это может привести к неправильному подсчету всякий раз, когда прерывание срабатывает после считывания pulseCount, но до его сброса.

// Обратите внимание на время выполнения этого прохода обработки. Обратите внимание, что потому что
// мы отключили прерывания, функция millis() на самом деле не будет
// увеличиваться прямо в этот момент, но она все равно вернет значение
// он был установлен как раз перед тем, как исчезли прерывания.
oldTime = millis();

Это замечание неверно. Оператор detachInterrupt(sensorInterrupt) отключает только внешнее прерывание. Он не отключает прерывания глобально и, в частности, не отключает прерывание таймера, которое увеличивает millis(). Поэтому нет никакой гарантии, что различные вызовы millis() вернут одно и то же значение в течение одной итерации. Вместо этого millis() следует вызывать только один раз, и его значение запоминается:

void loop()
{
    unsigned long now = millis();  // save this value
    if (now - oldTime >= 1000) {
        // ...
        oldTime = now;
    }
}

Обратите внимание, что я использую >=> для проверки задержки: с оператором >> период составляет не менее 1001 мс.

flowMilliLitres = (flowRate / 60) * 1000;

Это неверно. Так и должно быть

flowMilliLitres = (flowRate / 60) * (now - oldTime);

по той же причине, по которой сейчас - oldTime используется при вычислении расхода. Можно отметить, что это может быть упрощено до

flowMilliLitres = (1e3/calibrationFactor/60) * pulseCountDifference;

как факторы теперь - старое время отменяются.