// ***************************************************************
// *        Behringer XR18 Arduino MIDI Remote Control           *
// *                   By Vern Graner                            *
// ***************************************************************
// * This code connects to WiFI and sends OSC commands to an     *
// * Behringer XR18. You have to enter an IP address for the     *
// * mixer for this demo to work                                 *
// ***************************************************************
// * Rev Info: V1.0a (VLG) 01-22-2018 Basic proof of concept     *
// *         : V3.2a (VLG) 01-27-2018 CH1&2 mute, FOH/HOSTS PTT  *
// *         : V3.2a (VLG) 01-27-2018 PROTOTYPE1 NO OLED         *
// *         : V3.5a (VLG) 01-28-2018 Use array for OSC commands *
// *         : V3.5C (VLG) 02-06-2018 Cough Box V1               *
// ***************************************************************

#include <WiFi.h>             // For WiFi
#include <WiFiUdp.h>          // For WiFi

// Include the MIDI stuff
#include <OSCMessage.h>       // For OSC support
#include <MIDI.h>             // MIDI support
#include <midi_Defs.h>
#include <midi_Message.h>
#include <midi_Namespace.h>
#include <midi_Settings.h>

// Assign Button Functions
// ***************************************************

// define button arrays Format is "<OSC COMMAND>","<OSC PARAMETER>",
const char* buttonCommand[]={
  "/ch/01/mix/on","ON",         // Button 0 Up:   Ch 1 UN-MUTE
  "/ch/01/mix/on","OFF",        // Button 0 Down: Ch 1 MUTE
  "/ch/02/mix/on","ON",         // Button 1 Up:   Ch 2 UN-MUTE
  "/ch/02/mix/on","OFF",        // Button 1 Down: Ch 2 MUTE
  "/ch/03/mix/on","ON",         // Button 2 Up:   Ch 3 UN-MUTE
  "/ch/03/mix/on","OFF",        // Button 2 Down  Ch 3 MUTE
  "/ch/04/mix/on","ON",         // Button 3 Up    Ch 4 UN-MUTE
  "/ch/04/mix/on","OFF",        // Button 3 Down  Ch 4 MUTE
};  

// WiFi setup
// char ssid[] = "NETGEAR38";                    // your network SSID (name)
// char pass[] = "phobicrosebud574";             // your network password

 char ssid[] = "GRANER";                        // your network SSID (name)
 char pass[] = "frontera";                      // your network password


WiFiUDP Udp;                                // A UDP instance to let us send and receive packets over UDP
 const IPAddress outIp(192,168,77,100);        // IP of the XR18 in Comma Separated Octets, NOT dots!
// const IPAddress outIp(192,168,1,128);    // IP of the XR18 in Comma Separated Octets, NOT dots!
const unsigned int outPort = 10024;         // remote port to receive OSC X-AIR is 10024, X32 is 10023
const unsigned int localPort = 8888;        // local port to listen for OSC packets (actually not used for sending)

// Pin combos for Cough Drop Box
// Button/LED pin combos Button 0 15/25
// Button/LED pin combos Button 1 27/34
// Button/LED pin combos Button 0 32/39
// Button/LED pin combos Button 3 33/26

// Setup LED pins
int myLeds[]={15,27,32,33};         // define the pins for the LEDs
int ledCount=4;                     // set the number of LEDs in the loop

// Setup button pins
int myButtons[] = {25,34,39,26};    // define the pins for the buttons
int buttonCount = 4;                // set the number of buttons in the loop

// Button & LED Pair pin numbers:
// Button0 = 15, LED0 = 25
// Button1 = 27, LED0 = 34
// Button2 = 32, LED0 = 39
// Button3 = 33, LED0 = 26

// Setup button type
int buttonToggle[] = {0,0,0,0};     // "0" is for follow state 1 is for toggle state

// Define program Variables
int buttonState[] = {0,0,0,0};      // current state of the button
int lastButtonState[] = {0,0,0,0};  // previous state of the button


// MIDI OSC Hex converter
int commandLength=0;       
byte bigMidiCommand[64];   // maximum command length in bytes
byte midiHeader[]= { 0xF0,0x00,0x20,0x32,0x32 }; // XR18 OSC preamble
byte midiSpacer[]= { 0x20 };                     // XR18 OSC post-amble
byte midiFooter[]= { 0xF7 };                     // XR18 OSC post-amble

int count;                         // Command Counter
int i=0;                           // Button counter
int j=0;                           // bigMIDIcommand counter
int WiFiWait=0;                    // Wait Counter

HardwareSerial Serial1(2);         // setup MIDI on TX pin
MIDI_CREATE_INSTANCE(HardwareSerial,Serial1, midiOut); // create a MIDI object called midiOut

void setup() {
    Serial.begin(115200); // DEBUG window
    Serial1.begin(31250); // setup MIDI output
    midiOut.begin();
    //Setup pin mode for buttons
    for (int i=0;i<buttonCount; i++) { 
      pinMode(myButtons[i], INPUT_PULLUP); // initialize the button pin as a input
    }

    //Setp pin mode for LEDs
    for (int i=0; i<ledCount; i++) { // step through 0 to ledCount (which is 4 on this box)
      pinMode(myLeds[i], OUTPUT);    // initialize the LED as an output
    }
    
    // Print code version information
    Serial.println();
    Serial.println("********************************************************");
    Serial.println("*     WiFi/MIDI Mixer Control V3.5a 2018/01/29         *");
    Serial.println("*   Created by Vern Graner for use with X-AIR Mixers   *");
    Serial.println("********************************************************");
    Serial.println("* Contact: vern@graner.com / http://www.mugbbs.com/TAE *");                          
    Serial.println("********************************************************");
    Serial.println();

    // Connect to WiFi network
    Serial.print("Target WiFi SSID: "); 
    Serial.println(ssid);               
    Serial.print("Connecting"); 

    WiFi.begin(ssid, pass);
    while ( WiFiWait<60 && WiFi.status() != WL_CONNECTED) { // wait for either timeout or wifi to connect

        for (int count=0; count<4; count++) {      // step by 4 cells in array
        digitalWrite(myLeds[count], HIGH);         // blink LED to show we are waiting on WiFi              
        delay(100);       
        digitalWrite(myLeds[count], LOW);          // blink LED to show we are waiting on WiFi              
        delay(100);
        }
        
        Serial.print(".");
        WiFiWait++; // increment for timeout waiting for WiFi
    }

     // Check if WiFi connected
    if (WiFi.status() == WL_CONNECTED) {
          digitalWrite(myLeds[0], LOW);                  
          digitalWrite(myLeds[1], LOW);                  
          digitalWrite(myLeds[2], LOW);                  
          digitalWrite(myLeds[3], LOW);                  
          Serial.println("");
          Serial.println("Connected!");  
    } else {
          digitalWrite(myLeds[0], LOW);                  
          digitalWrite(myLeds[1], LOW);                  
          digitalWrite(myLeds[2], LOW);                  
          digitalWrite(myLeds[3], LOW);                  
          Serial.println("");
          Serial.println("Connection Timed Out!");  
          Serial.println("NOTE: Box is MIDI ONLY at this time!");
    }
    
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
    Serial.println("Starting UDP");
    Udp.begin(localPort);
    Serial.print("Local port: ");
    Serial.println(localPort);
    Serial.println("");

    Serial.print("Mixer IP: ");
    Serial.println(outIp);
    Serial.print("Mixer Port: ");
    Serial.println(outPort);    
}

void loop() { // Main Loop

  // ****************************************
  // Button Read Routine                    *
  // ***************************************************************************************

for (int count=0; count<15; count = count + 4)      //step by 4 cells in array
{
  buttonState[i] = digitalRead(myButtons[i]);       // read the pushbutton input pin
    if (buttonState[i] != lastButtonState[i]) {     // compare the buttonState to its previous state (if not equal)

      if (buttonState[i] == HIGH) {                 // if the current state is HIGH then the button went from OFF to ON

       //*******************************
       //* DEBUG Output                *
       //*******************************
         Serial.println("");
         Serial.print("Button "); Serial.print(i); Serial.println(" UP");
         Serial.print("OSC Message: [");          // to DEBUG screen
         Serial.print(buttonCommand[count]);      // to DEBUG screen
         Serial.print(" ");                       // to DEBUG screen
         Serial.print(buttonCommand[count+1]);    // to DEBUG screen
         Serial.println("]");                     // to DEBUG screen

       //*******************************
       //* MIDI OSC Message Send BEGIN *
       //***************************************
         midiBuildCommand(buttonCommand[count],buttonCommand[count+1]);
         midiOut.sendSysEx(commandLength, bigMidiCommand, true); // send SysEx
       //***************************************

       //*******************************
       //* WiFi OSC Message Send BEGIN *
       //***************************************
         OSCMessage msg(buttonCommand[count]);      // Send Button Message Command
         msg.add(buttonCommand[count+1]);           // Send Button Message Argument
         Udp.beginPacket(outIp, outPort);
         msg.send(Udp);
         Udp.endPacket();
         msg.empty();
       //***************************************

       // Set the LED
         digitalWrite(myLeds[i], LOW);                  

      } else {                                    // if the current state is LOW then the button went from ON to OFF

         Serial.println("");                      // to DEBUG screen
         Serial.print("Button "); Serial.print(i); Serial.println(" DOWN"); // to DEBUG screen
         Serial.print("OSC Message: [");          // to DEBUG screen
         Serial.print(buttonCommand[count+2]);    // to DEBUG screen
         Serial.print(" ");                       // to DEBUG screen
         Serial.print(buttonCommand[count+3]);    // to DEBUG screen
         Serial.println("]");                     // to DEBUG screen

       //*******************************
       // *MIDI OSC Message Send BEGIN *
       //***************************************
         midiBuildCommand(buttonCommand[count+2],buttonCommand[count+3]);
         midiOut.sendSysEx(commandLength, bigMidiCommand, true); // send SysEx
       //***************************************

       //*******************************
       // *WiFi OSC Message Send BEGIN *
       //***************************************
         OSCMessage msg2(buttonCommand[count+2]);
         msg2.add(buttonCommand[count+3]);
         Udp.beginPacket(outIp, outPort);
         msg2.send(Udp);
         Udp.endPacket();
         msg2.empty();
       //***************************************

       // Set the LED
         digitalWrite(myLeds[i], HIGH);                  
      }                                            
    delay(50);                                      // Delay a little bit to avoid bouncing
  }                                              
  lastButtonState[i] = buttonState[i];              // save the current state as the last state, for next time through the loop
  i=i+1;                                            // Button Counter iterate
//  delay(5000);                                    // DEBUG delay the loop to watch variables

}                                                   // END Button Read Loop 
i=0;                                                // reset the counter 

// **********************************************************
}//End of main loop


// Subroutines aka functions
// **********************************************************

// ***********************************
// Build the MIDI command from the   *
// two components of the OSC command *
// *************************************************************************
void midiBuildCommand(String body1,String body2) { // Pass OSC Command and Argument as body1, body2
  commandLength=0;
  for (int j=0 ; j <sizeof(midiHeader); j++) {
    bigMidiCommand[commandLength]=midiHeader[j]; // insert header into bigMidiCommand
    commandLength++;
  }

  for (int j=0 ; j <body1.length(); j++) {
    bigMidiCommand[commandLength]=body1[j];     // insert OSC Command into bigMidiCommand
    commandLength++;
  }

  for (int j=0 ; j <sizeof(midiSpacer); j++) {
    bigMidiCommand[commandLength]=midiSpacer[j]; // insert a space between OSC command and argument
    commandLength++;
  }

  for (int j=0 ; j <body2.length(); j++) {
    bigMidiCommand[commandLength]=body2[j];      // insert OSC Argument into bigMidiCommand
    commandLength++;
  }
 
  for (int j=0 ; j <sizeof(midiFooter); j++) {
    bigMidiCommand[commandLength]=midiFooter[j]; // insert OSC footer into bigMidiCommand
    commandLength++;
  }

  // DEBUG print the HEX string being sent to the MIDI port
  Serial.println("MIDI Message in HEX:");
  for (int j=0 ; j <29; j++)
  {
   bigMidiCommand[commandLength]=midiFooter[j];
   Serial.print("0x");
   Serial.print(bigMidiCommand[j],HEX);
   Serial.print(",");
  }
  Serial.println("");

}