possibility of motorized faders about control-surface HOT 9 CLOSED

#include <CapacitiveSensor.h>                  // Biblioteca para la sensibilidad táctil del fader
#include <MIDI.h>                                     // Biblioteca para recibir mensajes MIDI
MIDI_CREATE_DEFAULT_INSTANCE();
#define PitchBend 0xE0                             // Byte de estado para control de faders
#define AfterTouchChannel 0xD0              // Byte de estado para control de medidores
#define N 4                                               // Especifica aquí el numero de faders (max.8)
 
// Asignación de Pins en Arduino (MEGA)

const int motorUp[] = {23, 25, 27, 29, 31, 33, 35, 37};        // Controla H-Bridge para hacer que el motor ascienda
const int motorDown[] = {22, 24, 26, 28, 30, 32, 34, 36};      // Controla H-Bridge para hacer que el motor descienda
const int meterPin [] = {2, 3, 4, 5, 6, 7, 8, 9};              // pines PWM que se van a utilizar para los medidores

// Entradas 

const int fader[] = {0, 1, 2, 3, 4, 5, 6, 7}; // Pin de entrada analogica del fader relativo a GND
const int touchSend = 10;                     // Pin de envio para circuito de detección de capacitancia
const int touchReceive = 11;                  // Pin de recepción para circuito de detección de capacitancia

// Variables

double faderMax[N];                            // Valor leído por la posición máxima del fader (0-1023)
double faderMin[N];                            // Valor leído por la posición mínima del fader (0-1023)
double posicion[N];
int faderChannel[N];                           // Canal MIDI del fader (desde 1-8)
int returnValue[N];

int meterChannel  = 0 ;                        // Canal MIDI del medidor
int valueAT = 0;                               // Valor de lectura desde DAW
int valueMeter = 0;                            // Valor de salida para PWM

bool touched = false;
bool positionUpdated[N];

CapacitiveSensor touchLine = CapacitiveSensor(touchSend, touchReceive);

void setup() {  
  MIDI.begin(MIDI_CHANNEL_OMNI);               // Recibe mensajes en todos los canales MIDI
//  Serial.begin(115200);                        // habilitar esta linea para testear a traves de Hairless MIDI
 
  for (int i = 0; i < N; i++) {
    pinMode (motorUp[i], OUTPUT);
    pinMode (motorDown[i], OUTPUT); 
    faderMax[i] = 0 ;
    faderMin[i] = 0 ;
    posicion[i] = 0 ;
    faderChannel[i] = (i+1);
    positionUpdated[i] = false ;
    analogWrite (meterPin[i], valueMeter);     // Puesta a cero de medidores
  }
   calibrateFader();  
}

void loop() { 

  for (int i = 0; i < N; i++) {

    /* Si hay un mensaje MIDI en espera, y corresponde al actualmente seleccionado
      fader, y es un mensaje PitchBend (usado para controlar el fader), luego convierte
      el valor PitchBend y actualizar la posición actual del fader. */
    if (MIDI.read() && MIDI.getChannel() == faderChannel[i] && MIDI.getType() == PitchBend ) {

      /* Mapeo bit a bit para tomar dos valores de 7 bits para PitchBend y convertir a 
        un solo valor de 14 bits. Luego lo convierte en valor entre 0 y 1023
        para controlar el fader */
      int value = (((MIDI.getData2() << 7) + MIDI.getData1()) * 0.0625);
      updateFader(value, i);
      }
   
  checkTouch(i);                        //Comprueba si el fader está siendo tocado  
 
    if (!positionUpdated[i]) {          //Si se ha tocado el fader, necesita actualizar la posición en el DAW
      updateFaderMidi(i);      
      positionUpdated[i] = true;
    }

    if (MIDI.read() && MIDI.getType() == AfterTouchChannel && ((MIDI.getData1() & 0x70) >> 4) == i) {
    // meterChannel = (MIDI.getData1() & 0x70) >> 4;
    valueAT = MIDI.getData1() & 0x0F;                     // Extrae el valor necesario del mensaje MIDI
    valueMeter = map(valueAT, 0, 13, 0, 190);             // Transformar los valores recibidos por el DAW para la salida PWM
    analogWrite (meterPin[i], valueMeter);                // Emite el valor por PWM hacia el filtro RC.
    }    
  }
}

void checkTouch(int i) {                // Comprueba el sensor capacitivo,
                                        // el valor 700 es arbitrario y puede ser cambiado
                                        //          |||
  if (!touched && touchLine.capacitiveSensor(30) >= 700) {  
    touched = true;                                         // Si se ha tocado .. 
                                                            // Envia mensaje Touch on  al DAW 
    Serial.write(0x90);
    Serial.write(0x67 + faderChannel[i]);
    Serial.write(0x7f);
  }
  else if (touched && touchLine.capacitiveSensor(30) < 700) {
    touched = false;                                        // Si se ha dejado de tocar ..
                                                            // Envia mensaje Touch Off al DAW
    Serial.write(0x90);
    Serial.write(0x67 + faderChannel[i]);
    Serial.write((byte) 0x00);
  }
  if (touched) {                                            // 
    positionUpdated[i] = false;
  }
}

void updateFaderMidi(int i) {                   // Envia posicion del fader al DAW
 
    int volumen = faderPosition(i);
    byte channelData = 0xE0 + (faderChannel[i] - 1);

     // MIDI Message:
     Serial.write(channelData);                 // E(PitchBend) Channel (0-9)
     Serial.write(volumen & 0x7F);              // Bits de datos menos significativos
     Serial.write((volumen >> 7) & 0x7F);       // Bits de datos más significativos
}

//  Muever el fader a una posición específica entre 0-1023 si aún no está allí

void updateFader(int valuepos ,int i ) {                                   // Envia posicion del DAW al fader
  posicion[i] = valuepos;
  if (posicion[i] < analogRead(fader[i]) - 10 && posicion[i] > faderMin[i] && !touched) {
      digitalWrite(motorDown[i], HIGH);
      while (posicion[i] < analogRead(fader[i]) - 10 && !touched) {};      // Bucles hasta que el motor se mueve
      digitalWrite(motorDown[i], LOW);
  }
  else if (posicion[i] > analogRead(fader[i]) + 10 && posicion[i] < faderMax[i] && !touched) {
      digitalWrite(motorUp[i], HIGH);
      while (posicion[i] > analogRead(fader[i]) + 10 && !touched) {};      // Bucles hasta que el motor se mueve
      digitalWrite(motorUp[i], LOW);
  }
}
int faderPosition(int i) {   
      posicion[i] = analogRead(fader[i]);
      
  if (posicion[i] <= faderMin[i]) {
      returnValue[i] = 0;
  }
  else if (posicion[i] >= faderMax[i]) {
      returnValue[i] = 16383;
  }
  else {
      returnValue[i] = ((float)(posicion[i] - faderMin[i]) / (faderMax[i] - faderMin[i])) * 16383;
  }
  return returnValue[i];      
}

void calibrateFader() {
  for (int i = 0; i < N; i++) {
                                                 // Enviar faders a la parte superior y leer las posiciónes máximas
    digitalWrite(motorUp[i], HIGH);
    delay(300);
    digitalWrite(motorUp[i], LOW);
    faderMax[i] = analogRead(fader[i]) - 5;
  }
  for (int i = 0; i < N; i++) { 
                                                 // Enviar faders a la parte inferior y leer las posiciónes mínimas
    digitalWrite(motorDown[i], HIGH);
    delay(300);
    digitalWrite(motorDown[i], LOW);
    faderMin[i] = analogRead(fader[i]) + 5;
  }
}