Во-первых, вам нужен надежный способ синхронизации и анализа MIDI-сообщений, которые могут быть размером 1 байт, 2 байта или 3 байта или более... Смотрите это Краткое описание сообщений MIDI 1.0, полученных ассоциациейMIDI.

Хороший способ достичь этого - использовать State Machine. Ниже я написал простое приложение, которое анализирует 3-байтовые MIDI-сообщения. Он может быть расширен для анализа различных типов команд.

typedef enum State
{
    Idle,
    Command,
    Data1
};

State state = State::Idle;

const float INCOMING_VELOCITY_SCALE = 1023.0 / 127.0;

byte incomingCommand;
byte incomingNote;
byte incomingVelocity;

int targetPosition;

void loop()
{
    if (midiSerial.available())  // Используйте оператор "if", чтобы получить следующий доступный байт.
    {
        byte incoming = midiSerial.read();

        // Синхронизируйте и проанализируйте 3-байтовый пакет MIDI-сообщений, т. е. 1nnnnnnn 0nnnnnn 0nnnnnn
        switch (state)
        {
        case State::Idle:
            if (IsMidiCommand(incoming))
            {
                Serial.println("Received command byte.");
                incomingCommand = incoming;
                state = State::Command;
            }
            else if (IsMidiData(incoming))
            {
                Serial.println("Received data byte.");
            }
            break;
        case State::Command:
            if (IsMidiCommand(incoming))  // Дважды проверьте, нет ли команды несинхронизации.
            {
                Serial.println("Received command byte.");
                incomingCommand = incoming;
                state = State::Command;
            }
            else if (IsMidiData(incoming))
            {
                Serial.println("Received data1 byte.");
                incomingNote = incoming;
                state = State::Data1;
            }
            break;
        case State::Data1:
            if (IsMidiCommand(incoming))  // Тройная проверка на несинхронизацию команды.
            {
                Serial.println("Received command byte.");
                incomingCommand = incoming;
                state = State::Command;
            }
            else if (IsMidiData(incoming))
            {
                Serial.println("Received data2 byte.");
                incomingVelocity = incoming;
                midiSerial.write(incomingCommand);
                midiSerial.write(incomingNote);
                midiSerial.write(incomingVelocity);
                Serial.write(incomingCommand);
                Serial.write(incomingNote);
                Serial.write(incomingVelocity);
                Serial.println();
                targetPosition = incomingVelocity * INCOMING_VELOCITY_SCALE;
                if (targetPosition > faderMax)
                {
                    targetPosition = faderMax;
                }
                else if (targetPosition < faderMin)
                {
                    targetPosition = faderMin;
                }
                state = State::Idle;
            }
            break;
        default:
            state = State::Idle;
            break;
        }
    }
    . . .
    updateFader(targetPosition);
    . . .
}

bool IsMidiCommand(const byte b)
{
    return b >= 128;  // Для байтов MIDI-команд MSB равно 1.
}

bool IsMidiData(const byte b)
{
    return b <= 127;  // Для байтов MIDI-данных MSB равно 1.
}

Во-вторых, существует проблема с функцией updateFader (), связанная с допуском. Это 40 в вашей первой версии и 10 во второй версии. Рассмотрим следующие значения переменных:

// В setup()
digitalWrite(motorDown, HIGH);
analogWrite(motorPWM, motorSpeed);
delay(300);
faderMin = analogRead(wiper) + tolerance;
faderMin = 0                 + 40;         // Нижняя граница диапазона.
faderMin = 40;

// В loop()
incomingVelocity = midiSerial.read() * 8.05511811024;
incomingVelocity = 1                 * 8.05511811024;  //Тихая заметка, например, от 0 до 5, даст значение от 0 до 40.
incomingVelocity = 8;

// В updateFader()
if (position < analogRead(wiper) - tolerance && position > faderMin)
if (8        < 512               - 40        && 8        > 40      )
if (8        < 472                           && 8        > 40      )
if (true                                     && false              )
if (false                                                          )

Результат: фейдер не сдвинется с места, если будет получена тихая нота, которая ставит позицию ниже Фадермина и приведет к тому, что фейдер заклиниет где-то в середине шкалы, а не перейдет к Фадермину. Этот эффект был бы преувеличен, если бы faderMin был выше 40, когда analogRead(стеклоочиститель) считывает больше нуля в setup().

Точно так же это происходит и с очень громкими нотами и Фадермаксом на другом конце шкалы:

// В updateFader()
else if (position > analogRead(wiper) + tolerance && position < faderMax)

Лучшим способом было бы обрезать целевую позицию до допустимого диапазона перед вызовом функции updateFader() и удалить второе условие из операторов if в функции updateFader():

targetPosition = incomingVelocity * INCOMING_VELOCITY_SCALE;
if (targetPosition > faderMax)      // Clip if out of bounds.
{
    targetPosition = faderMax;
}
else if (targetPosition < faderMin)
{
    targetPosition = faderMin;
}
. . .
updateFader(targetPosition);
. . .
if (position < analogRead(wiper) - tolerance)
. . .
else if (position > analogRead(wiper) + tolerance)
. . .

В-третьих, updateFader() блокируется до тех пор, пока двигатель фейдера не закончит движение. Если ноты принимаются быстрее, чем фейдер может двигаться, темп значительно возрастет, поэтому рассмотрите возможность использования неблокирующего стиля, такого как Мигание без задержки.

В – четвертых, faderMin и faderMax должны быть именно такими-минимальной и максимальной степенью путешествия фейдера. Но, добавляя/вычитая допуск из min/max, это излишне уменьшает диапазон. Допуск фактически удваивается, подстраиваясь под него как в setup (), так и в adjustFader(). Степень перемещения фейдера можно получить, приняв в среднем несколько значений в calibrateFader(). Затем допуск можно настроить только один раз в функции adjustFader (), как описано выше.

void calibrateFader()
{
    const byte NUM_SAMPLES = 10;
    digitalWrite(motorUp, HIGH);
    analogWrite(motorPWM, motorSpeed);
    delay(300);
    digitalWrite(motorUp, LOW);
    faderMax = AnalogueAverage(wiper, NUM_SAMPLES);
    Serial.println(faderMax);
    digitalWrite(motorDown, HIGH);
    analogWrite(motorPWM, motorSpeed);
    delay(300);
    digitalWrite(motorDown, LOW);
    faderMin = AnalogueAverage(wiper, NUM_SAMPLES);
    Serial.println(faderMin);
}

unsigned int AnalogueAverage(const byte pin, const byte num_samples)
{
    const byte ROUND_OFF = num_samples / 2;
    unsigned long total = 0;
    for (byte i = 0; i < num_samples; i++)
    {
        total += analogRead(pin);
    }
    return (total + ROUND_OFF) / num_samples;
}

На другой ноте...

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

1. Контрольная поверхность
2. Библиотека Arduino MIDI

Они уже реализуют анализ MIDI-сообщений с помощью обратных вызовов, например:

• Использование обратных вызовов
• Использование обратных вызовов .ino

Этот пример подчеркивает важность быстрого неблокирующего кода. Это означает, что функция updateFader() также должна быть неблокирующей. У вас есть возможность написать свой собственный парсер конечных автоматов или использовать парсеры библиотек.

Вот как можно переписать ваш код, чтобы использовать анализатор библиотеки MIDI с неблокирующими обратными вызовами и неблокирующим updateFader(). Возможно, вам захочется дважды проверить, какие контакты вы используете для midiSerial, поскольку контакты 0 и 1 используются для последовательного монитора по умолчанию, или вы можете использовать MIDI.sendNoteOn() и MIDI.sendNoteOff().

#include <MIDI.h>

MIDI_CREATE_DEFAULT_INSTANCE();

unsigned int faderMax = 0;
unsigned int faderMin = 0;
unsigned int faderTargetPosition = 0;

void doNoteOn(byte channel, byte note, byte velocity)
{
    midiSerial.write(channel);
    midiSerial.write(note);
    midiSerial.write(velocity);
    faderTargetPosition = velocity * INCOMING_VELOCITY_SCALE;

    // Clip if out of bounds.
    if (faderTargetPosition > faderMax)
    {
        faderTargetPosition = faderMax;
    }
    else if (faderTargetPosition < faderMin)
    {
        faderTargetPosition = faderMin;
    }
}

void doNoteOff(byte channel, byte note, byte velocity)
{
    midiSerial.write(channel);
    midiSerial.write(note);
    midiSerial.write(velocity);
}

void setup()
{
    MIDI.setHandleNoteOn(doNoteOn);
    MIDI.setHandleNoteOff(doNoteOff);
    MIDI.begin(MIDI_CHANNEL_OMNI);
    . . .
}

void loop()
{
    // Анализируйте MIDI-сообщения и вызывайте обратные вызовы.
    MIDI.read();

    if ((millis() - lastDebounceTime) > debounceDelay)
    {
        int totalCp = touch.capacitiveSensor(30);
        int faderPos = analogRead(FADER_PIN);
        int faderHiResMIDI = faderPos * 16.0146627566 - 8191.5;

        if (totalCp <= minimumCp)
        {
            // Не трогаю фейдер.
            //if (incomingCommand == ch1Vol)
            //{
            updateFader(faderTargetPosition);
            //}
        }
        else
        {
            if (faderPos == lastfaderValue)
            {
                // Touching fader.
                MIDI.sendNoteOn(Db_1, fullVel, ch_1);
                digitalWrite(MOTOR_DOWN_PIN, LOW);
                digitalWrite(MOTOR_UP_PIN, LOW);
            }
            else if ((faderPos > lastfaderValue + 1) or (faderPos < lastfaderValue - 1))
            {
                // Moving fader.
                MIDI.sendPitchBend(faderHiResMIDI, ch_1);
                digitalWrite(MOTOR_DOWN_PIN, LOW);
                digitalWrite(MOTOR_UP_PIN, LOW);
            }
        }
        lastfaderValue = faderPos;
        lastDebounceTime += debounceDelay;  // Постоянный интервал.
    }
}

void updateFader(const unsigned int& faderTargetPosition)
{
    const unsigned int currentPosition = analogRead(FADER_PIN);
    if (faderTargetPosition < currentPosition - tolerance)      // Below the tolerance band.
    {
        digitalWrite(MOTOR_UP_PIN, LOW);                        // Выключите регулятор "Вверх" перед включением регулятора "вниз".
        digitalWrite(MOTOR_DOWN_PIN, HIGH);
    }
    else if (faderTargetPosition > currentPosition + tolerance) // Выше диапазона допуска.band.
    {
        digitalWrite(MOTOR_DOWN_PIN, LOW);                      // Выключите регулятор "Вниз" перед включением регулятора "вверх".
        digitalWrite(MOTOR_UP_PIN, HIGH);
    }
    else                                                        // В пределах допустимого диапазона.
    {
        digitalWrite(MOTOR_DOWN_PIN, LOW);
        digitalWrite(MOTOR_UP_PIN, LOW);
    }
}