POST_73

/*  TITULO: Batería MIDI con Pro Tools 10 y EZ Drummer.

    AUTOR:

    MARIANO DEL CAMPO GARCÍA (@2016) --> INGENIERO TÉCNICO INDUSTRIAL ESPECIALIDAD ELECTRÓNICA
    - FACEBOOK: https://www.facebook.com/mariano.delcampogarcia
    - TWITTER: https://twitter.com/MarianoCampoGa
    - CORREO: marianodc83@gmail.com


    DESCRIPCIÓN DEL PROGRAMA

    Con este programa enviamos mensajes MIDI con una velocidad de 57600 BAUDIOS desde ARDUINO al PC,
    a través del puerto serie USB, cada vez que golpeemos uno de los PADS o cada vez que presionemos
    el pedal del Bombo, para que sean leídos por Pro Tools a través de una entrada MIDI, gracias al
    conversor serie a MIDI y el puerto virtual MIDI (LoopBe) que tenemos que instalar para que se
    reproduzcan los sonidos de batería del "Plugin" EZ Drummer (Caja, TOMS, platillos y bombo).
    Este mensaje MIDI que enviamos, consta de tres partes claramente diferenciadas:
    - STATUS: Compuesto por el estado de la NOTA MIDI(ON/OFF) y el canal MIDI por el que transmitimos.
    - TONO: Es el TONO de la NOTA MIDI que transmitimos (de 0 a 127).
    - VELOCIDAD: Es la velocidad con la que se reproduce la NOTA MIDI que transmitimos (de 0 a 127).
    Podremos personalizar dentro del programa el canal MIDI por el que se realiza la transmisión del
    mensaje MIDI, los tonos de las NOTAS MIDI reproducidas al golpear los PADS o al pisar el pedal
    del Bombo, la sensibilidad para la activación de los PADS, el tiempo de espera (respuesta) entre
    el golpeo de los PADS o cuando pisamos dos veces el pedal del Bomboo y por último la velocidad del
    pedal del Bombo. Para una mayor información sobre el programa os recomiendo revisar los comentarios
    realizados a lo largo del mismo.


    ESQUEMA DE CONEXION

                                           +-----+
              +----[PWR]-------------------| USB |--+
              |                            +-----+  |
              |         GND/RST2  [ ][ ]            |
              |       MOSI2/SCK2  [ ][ ]  A5/SCL[ ] |
              |          5V/MISO2 [ ][ ]  A4/SDA[ ] |
              |                             AREF[ ] |
              |                              GND[ ] |
              | [ ]N/C                    SCK/13[ ] |
              | [ ]IOREF                 MISO/12[ ] |  LED_Charles(+)
              | [ ]RST                   MOSI/11[ ]~|  LED_Bombo(+)
              | [ ]3V3    +---+               10[ ]~|  PA (pulsador_bombo)
              | [ ]5v    -| A |-               9[ ]~|  PA (pedal)
              | [ ]GND   -| R |-               8[ ] |  PA (Charles)
              | [ ]GND   -| D |-                    |
              | [ ]Vin   -| U |-               7[ ] |  LEDS 1(+)
              |          -| I |-               6[ ]~|  LEDS 2(+)
  PIEZO 1(+)  | [ ]A0    -| N |-               5[ ]~|  LEDS 3(+)
  PIEZO 2(+)  | [ ]A1    -| O |-               4[ ] |  LEDS 4(+)
  PIEZO 3(+)  | [ ]A2     +---+           INT1/3[ ]~|  LEDS 5(+)
  PIEZO 4(+)  | [ ]A3                     INT0/2[ ] |  LEDS 6(+)
  PIEZO 5(+)  | [ ]A4/SDA  RST SCK MISO     TX>1[ ] |
  PIEZO 6(+)  | [ ]A5/SCL  [ ] [ ] [ ]      RX<0[ ] |
              |            [ ] [ ] [ ]              |
              |  UNO_R3    GND MOSI 5V  ____________/
               \_______________________/

  NOTAS:
   - El terminal(-) de todos los PIEZOS a GND.
   - Resistencia de 1M ohm entre los terminales (+) y (-) de cada PIEZO.
   - Los pulsadores suelen tener dos pines, que vamos a denominar PA y PB (si es de 4 sólo usamos 2 de ellos)
   - Conexión PULL-DOWN de los pulsadores
       - Pulsador_bombo:
         - PB (Pulsador_bombo) conectado a VCC.
         - PA (Pulsador_bombo) conectado a GND a través de una R=10K ohms.
       - Pedal Charles:
         - PB (Charles) conectado a VCC.
         - PA (Charles) conectado a GND a través de una R=10K ohms.
       - Pedal Bombo:
         - PB (pedal) conectado a VCC.
         - PA (pedal) conectado a GND a través de una R=10K ohms.
   - Cátodo(-) de todos los LEDS (pata más corta) a GND a través de una R=220 ohms, una para cada grupo de LEDS.


  SOTWARE REQUERIDO:

   -> Puerto MIDI Virtual - loopBE: https://mega.nz/#!as40kIaY!P8gPtd1ZidftKjnIS316M2wncZRe5mfwBOW-rOV2P_U
   -> Conversor - Serial_MIDI_Converter_V2D: https://mega.nz/#!PooVGZza!SuRLVJEfNJ_54oIMQEQMceEfMc7jGLNBG2xsY7bh9FU
   -> Pro Tools 10: https://mega.nz/#!m4JzFBBQ!T4DZ49dqpnBxL2B0-fpl1ncu8X605eoyqTlaq-gv5M0
   -> EZ Drummer: https://mega.nz/#!u8BDWYwZ!39pimPFn63hweH6XwEcvPgceVAAd9nlVJ1ZsvvUM07E
*/

  // Canal MIDI del 0 a 15, +1 en el "mundo real" (Utilizo el 8 porque le configuro en Pro Tools 10).
  #define  canal    7;

  // Notas MIDI de 0 a 127 (Mid C = 60) --> {Charles abierto, Caja, TOM 1, TOM 2, TOM de piso, platillos}.
  unsigned char Nota[6] = {46,33,50,47,43,58};

  int Nota_pedal = 36; // Nota MIDI para el Bombo.

  int Sensibilidad_golpeo[6] = {400,400,400,400,400,400};   // Valor máximo 1023. A mayor valor menor sensibilidad.

  // Tiempo de espera entre golpes en milisegundos (respuesta). A mayor valor menor respuesta de la batería electrónica.
  int Respuesta[6] = {90,90,90,90,90,90};

  // Variables para el control del pedal del Bombo.
  int Velocidad_pedal = 120; // Velocidad del pedal entre 0 y 127 (elige la que más te guste).
  int Tiempo_maximo = 70; // Tiempo de espera del pedal para poder pisarle por segunda vez (Respuesta del pedal)

  boolean Bandera_velocidad  = true; // Variable interna para el control de la velocidad.

  // Variables para el control de los PADS
  boolean Pad_Activo[6] = {0,0,0,0,0,0}; // Matriz que almacena el estado inicial de los PADS (OFF).
  int Comienzo_sonido[6] = {0,0,0,0,0,0}; // Matriz para contar el tiempo que dura la NOTA al golpear cada PAD.

  // Variables internas para el pedal del Bombo
  int tiempo_pedal = 0;   // Cuenta el tiempo desde que pisamos el pedal (inicialmente cero).
  boolean bombo_activo = false; // Estado inicial del pedal del Bombo.

  unsigned char status; // Variable para almacenar el ESTADO del mensaje MIDI (Estado NOTA MIDI <ON/OFF> + CANAL).

  int Nota_ON = 144; // Variable con valor 144 que activa la NOTA MIDI.
  int Nota_OFF = 128; // Variable con valor 128 que desactiva la NOTA MIDI.

  int pedal = 9; // Pin digital para el interruptor del pedal del bombo
  int valor_pedal; // Variable para almacenar el estado del pedal
  int pin = 0; // Variable auxiliar para recorrer las matrices (Arrays)
  int velocidad = 0; // Variable interna para el control de la velocidad de las NOTAS
  int LED_bateria[6] = {7, 6, 5, 4, 3, 2}; // Pines digitales para los LEDs de los PADS
  int LED_Bombo = 11; // Pin digital para el LED del estado del Bombo
  int LED_Charles = 12; // Pin digital para el LED del estado del Charles

  // Variables para la función del BOMBO y DOBLE BOMBO
  const int pulsador_bombo = 10; // Pin digital para el pulsador del MODO del Bombo
  const int tiempoAntirrebote = 10; // Tiempo en ms para evitar el rebote del pulsador del Bombo

  // Variables para el control del pulsador del Bombo
  int cuenta = 0;
  int estadoBoton;
  int estadoBotonAnterior;

  // Variables para la función del CHARLES
  int charles = 8; // Pin digital para el pedal del charles
  int estado_charles; // Variable que almacena el estado del pedal del Charles


  void setup()
  {
    Serial.begin(57600); // Comienza la comunicación serie a 57600 BAUDIOS

    pinMode(LED_Charles, OUTPUT); // Pin digital 12 como SALIDA
    pinMode(LED_Bombo, OUTPUT); // Pin digital 11 como SALIDA
    pinMode(pulsador_bombo, INPUT); // Pin digital 10 como ENTRADA
    pinMode(pedal, INPUT); // Pin digital 9 como ENTRADA
    pinMode(charles, INPUT); // Pin digital 8 como ENTRADA

    // Pines digitales del 7 al 2 como SALIDAS
    for(int i=0; i<6; i++)
    {
      pinMode(LED_bateria[i], OUTPUT);
    }
  }


  void loop()
  {
    // Función que cambia la NOTA MIDI del charles en función del ESTADO del pedal charles
    NOTA_Charles();

    // Función para controlar los PADS
    CONTROL_PADS();

    // Función para controlar el BOMBO
    CONTROL_Bombo();
  }


  // Función que transmite el mensaje MIDI
  void MIDI_TX(unsigned char MENSAJE, unsigned char TONO, unsigned char VELOCIDAD)
  {
    status = MENSAJE + canal; // Estado de la NOTA MIDI (ON/OFF) + canal MIDI de transmisión
    // Enviamos los valores por el puerto serie USB de ARDUINO
    Serial.write(status); // Estado del mensaje
    Serial.write(TONO); // Tono de la NOTA MIDI
    Serial.write(VELOCIDAD); // Velocidad de la NOTA MIDI
  }

  // Función que cambia la NOTA MIDI del charles en función del ESTADO del pedal charles
  void NOTA_Charles()
  {
    // Obtenemos el valor del pedal del Charles
    estado_charles = digitalRead(charles);

    // Si no hemos pisado el pedal del Charles
    if(estado_charles == LOW)
    {
      Nota[0] = 46; // Nota MIDI para Charles abierto
      digitalWrite(LED_Charles, LOW); // LED del Charles apagado
    }

    // Si hemos pisado el pedal del Charles
    if(estado_charles == HIGH)
    {
      Nota[0] = 42; // Nota MIDI para Charles cerrado
      digitalWrite(LED_Charles, HIGH); // LED del Charles encendido
    }
  }

  // Función para controlar los PADS
  void CONTROL_PADS()
  {
    // Recorremos las 6 entradas analógicas (A0, A1,....A5)
    for(int pin=0; pin < 6; pin++)
    {
      // Guardamos el valor analógico de la entrada
      velocidad = analogRead(pin);
      // Si el golpe está dentro del tiempo de respuesta ..
      if((velocidad > Sensibilidad_golpeo[pin]))
      {
        // Si el PAD no estaba activado
        if((Pad_Activo[pin] == false))
        {
          // Calculamos la velocidad de golpeo
          if(Bandera_velocidad == true)
          {
            velocidad = (velocidad / 8) -1 ;
          }
          else
          {
            velocidad = 127;
          }
          // Enviamos el mensaje MIDI para encender la NOTA
          MIDI_TX(Nota_ON,Nota[pin],velocidad);
          Comienzo_sonido[pin] = 0;
          Pad_Activo[pin] = true;
          digitalWrite(LED_bateria[pin], HIGH); // Activamos los LEDS del PAD
        }
        // Si no hemos golpeado el PAD correspondiente
        else
        {
          // Incremento el tiempo entre golpes en una unidad
          Comienzo_sonido[pin] = Comienzo_sonido[pin] + 1;
        }
      }
      // Si el PAD estaba ya activado
      else if((Pad_Activo[pin] == true))
      {
        // Incremento el tiempo entre golpes en una unidad
        Comienzo_sonido[pin] = Comienzo_sonido[pin] + 1;

        // Si se ha superado el tiempo de respuesta
        if(Comienzo_sonido[pin] > Respuesta[pin])
        {
          // Enviamos el mensaje MIDI para apagar la NOTA
          MIDI_TX(Nota_OFF,Nota[pin],127);
          Pad_Activo[pin] = false;
          digitalWrite(LED_bateria[pin], LOW); // Desactivamos los LEDS del PAD
        }
      }
    }
  }

  // Función para controlar el BOMBO
  void CONTROL_Bombo()
  {
    // Se adquiere el estado del pulsador del bombo
    estadoBoton = digitalRead(pulsador_bombo);

    // Se cuentan las veces que lo hemos pulsado
    if(estadoBoton != estadoBotonAnterior)
    {
      if(antirrebote(pulsador_bombo))
      {
        cuenta++;
      }
    }
    estadoBotonAnterior = estadoBoton;

    // Se reinicia la cuenta cuando llega a 2
    if(cuenta==2)
    {
      cuenta = 0;
    }

    // Se adquiere el estado del pedal del bombo
    valor_pedal = digitalRead(pedal);

    // Se evalúa el valor de la cuenta del pulsador del bombo
    switch(cuenta)
    {
      // Bombo normal: LED apagado
      case 0:
        digitalWrite(LED_Bombo, LOW);
        pedal_Bombo();  // Función para "Bombo simple"
        break;

      // Doble bombo: LED encendido
      case 1:
        digitalWrite(LED_Bombo, HIGH);
        pedal_doble_Bombo(); // Función para "doble Bombo"
        break;
    }
  }

  // Función para "Bombo simple"
  void pedal_Bombo()
  {
    // Si hemos pisado el pedal del bombo
    if(valor_pedal == HIGH)
    {
      // Si el bombo estaba desactivado
      if((bombo_activo == false))
      {
        // Enviamos el mensaje MIDI para encender la NOTA
        MIDI_TX(Nota_ON,Nota_pedal,Velocidad_pedal);
        tiempo_pedal = 0;
        bombo_activo = true;
      }
      // Si el bombo estaba ya activado
      else
      {
        // Incremento el tiempo entre pisadas del pedal en una unidad
        tiempo_pedal = tiempo_pedal + 1;
      }
    }

    // Si no hemos pisado el pedal del bombo
    else if((bombo_activo == true))
    {
      // Incremento el tiempo entre pisadas del pedal en una unidad
      tiempo_pedal = tiempo_pedal + 1;

      // Si se ha superado el tiempo de respuesta
      if(tiempo_pedal > Tiempo_maximo)
      {
        // Enviamos el mensaje MIDI para apagar la NOTA
        MIDI_TX(Nota_OFF,Nota_pedal,Velocidad_pedal);
        bombo_activo = false;
      }
    }
  }

  // Función para "doble Bombo"
  void pedal_doble_Bombo()
  {
    // Si hemos pisado el pedal del bombo
    if(valor_pedal == HIGH)
    {
      // Si el bombo estaba desactivado
      if((bombo_activo == false))
      {
        // Enviamos el mensaje MIDI para encender la NOTA
        MIDI_TX(Nota_ON,Nota_pedal,Velocidad_pedal);
        delay(45); // Tiempo de espera
        // Enviamos el mensaje MIDI para apagar la NOTA
        MIDI_TX(Nota_OFF,Nota_pedal,Velocidad_pedal);
        delay(45); // Tiempo de espera
        // Enviamos el mensaje MIDI para encender la NOTA
        MIDI_TX(Nota_ON,Nota_pedal,Velocidad_pedal);
        tiempo_pedal = 0;
        bombo_activo = true;
      }
      // Si el bombo estaba activado
      else
      {
        // Incremento el tiempo entre pisadas del pedal en una unidad
        tiempo_pedal = tiempo_pedal + 1;
      }
    }
    // Si no hemos pisado el pedal del bombo
    else if((bombo_activo == true))
    {
      // Incremento el tiempo entre pisadas del pedal en una unidad
      tiempo_pedal = tiempo_pedal + 1;

      // Si se ha superado el tiempo de respuesta
      if(tiempo_pedal > Tiempo_maximo)
      {
        // Enviamos el mensaje MIDI para apagar la NOTA
        MIDI_TX(Nota_OFF,Nota_pedal,Velocidad_pedal);
        bombo_activo = false;
      }
    }
  }

  // Función que evita el rebote del pulsador del bombo
  boolean antirrebote(int pin)
  {
    int contador = 0;
    boolean estado;
    boolean estadoAnterior;

    do
    {
      estado = digitalRead(pin);
      if(estado != estadoAnterior)
      {
        contador = 0;
        estadoAnterior = estado;
      }
      else
      {
        contador = contador+ 1;
      }
      delay(1);
    } while(contador < tiempoAntirrebote);

    return estado; // Devuelve el valor del ESTADO del pulsador
  }