// 
// Foot Switches
// -------------
//
// Programmable foot switches.
//
// Public Domain
// February 2013
// 
// Using:
//    Arduino Leonardo R3
//    Arduino 1.0.3
//
// Each switch is programmable with the Arduino codes for keyboard and mouse.
// The serial port (via USB) of the Arduino Leonardo is used to program the switches.
// The codes for the switches are stored in EEPROM.
//
// The simulated key is pressed as long as the foot switch is pressed.
// This is useful if a key needs to be pressed continuously, like in games and virtual worlds.
//
// The switches are connected to the Arduino Leonardo pins, and to ground.
// All digital pins 0 to 13 can be used, and also A0 to A5.
// Set the used pins in the code in the "pinSwitch" array.
// The internal pull-up resistor is used, but external pull-up resistors of 10k would be better.
//
// To initialize the codes, send the command 'INIT'.
// Do this only once.
//
// A serial monitor or terminal program can be used to program the switches.
// Set it to 9600,8,N,1
// In a serial terminal, type '?' followed by Enter for info.
// The commands must be transmitted without delay between the characters,
// due to a very simple timeout.
//
// The command line can be used to program the switches.
// With a few command line scripts, the foot switches can be programmed for a specific task.
//
// Foot switch programming command: 
//    #xKKMM\r\n
//       #, The '#' is used as a start character
//       x, The switch number, starting from 0
//       KK, The keyboard code as 2 hexadecimal numbers.
//             A code from the ASCII table, 
//             or a special key, see USBAPI.h
//             Set to 00 if not used"
//       MM, The mouse code as 2 hexadecimal numbers.
//             01 is left mouse button
//             02 is right mouse button
//             04 is middle mouse button
//             Set to 00 if not used"
//       \r\n, Any trailing \r\n is ignored.
//
// Examples: 
//        #0DA00   set switch 0 to cursor up
//        #10001   set switch 1 to left mouse click
//
//
// Windows, PowerShell
//    Get the serial port names:
//      [System.IO.Ports.SerialPort]::getportnames()
//
//    Write the 'INIT' command (using COM9)
//      $port= new-Object System.IO.Ports.SerialPort COM9,9600,None,8,one; $port.open(); $port.WriteLine("INIT"); $port.Close()
//
//    Program a switch (using COM9)
//      $port= new-Object System.IO.Ports.SerialPort COM9,9600,None,8,one; $port.open(); $port.WriteLine("#0DA00"); $port.Close()
//
// Linux
//    Set the serial port baudrate (using ttyACM0)
//      stty -F /dev/ttyACM0 speed 9600
//    
//    Write the 'INIT' command (using ttyACM0)
//      echo "INIT" > /dev/ttyACM0
//
//    Program a switch (using ttyACM0)
//      echo "#0DA00" > /dev/ttyACM0
//
//
// Possible improvements:
//    - Better debounce.
//    - Better timeout for serial commands.
//    - A sequence of key presses and releases per switch.
//    - Repetitive keystrokes or mouse clicks while the switch is active.
//
//
//
// EEPROM usage:
//     address 0 : two bytes for foot switch 0
//                 first byte : keyboard code, 0 if not used.
//                 second byte : mouse code, 0 if not used.
//     address 2 : two bytes for foot switch 1
//     ... and so on
//
//


#include <EEPROM.h>

#define NUMBER_SWITCHES 3          // the total number of foot switches

// Set the used Arduino pins in the pinSwitch variable
// Write your own pin numbers here for the connected switches !
const int pinSwitch[NUMBER_SWITCHES] = {10, 9, 8};

// boolean variable to remember if switch is pressed at the moment.
boolean active[NUMBER_SWITCHES];

char buffer[20];                  // common buffer


void setup() 
{
  int i;
  
  Serial.begin(9600);
  
  // Set pins for switches to input.
  // Use internal pull-up resistor.
  // A external 10k pull-up resistor would be better.  
  for( i=0; i<NUMBER_SWITCHES; i++)
    pinMode(pinSwitch[i], INPUT_PULLUP);

  // Assume no switches are active.
  for( i=0; i<NUMBER_SWITCHES; i++)
    active[i] = false;

  // Initialize mouse and keyboard control.
  Keyboard.begin();
  Mouse.begin();
}


void loop()
{
  if( Serial.available() > 0)
    SerialTask();
  else
    ProcessSwitches();
}


int SerialTask( void)
{
  int i, j, keyboardCode, mouseCode;
  char inChar;

    
  inChar = Serial.read();
  
  switch( inChar)
  {
  case '#':
    // A command to program a code for a switch.
    // Wait for all characters to get in the buffer.
    // This is done with a delay, which is used as a timeout.
    delay( 100);
    
    // If not enough characters are received, ignore everything.
    if (Serial.available() < 5)
      return( -1);

    // The next character is the ascii number of the switch.    
    inChar = Serial.read();
      
    i = inChar - '0';
    
    // Test if the switch number is valid.
    if (i < 0 || i >= NUMBER_SWITCHES)
      return( -2);

    // Read two hexadecimal numbers for keyboard code.
    buffer[0] = Serial.read();
    buffer[1] = Serial.read();
    buffer[2] = '\0';
    // Convert ascii hex string to integer
    // No error checking for non-hexadecimal characters at the moment.
    keyboardCode = strtol( buffer, NULL, 16);
      
    // Read two hexadecimal numbers for mouse code
    buffer[0] = Serial.read();
    buffer[1] = Serial.read();
    buffer[2] = '\0';
    // Convert ascii hex string to integer
    // No error checking for non-hexadecimal characters at the moment.
    mouseCode = strtol( buffer, NULL, 16);
      
    // Test if the switch is pressed.
    // And release it first, before accepting the new codes.
    if( active[i])
    {
      j = EEPROM.read( (2*i) + 0);     // keyboard code
      if( j != 0)
        Keyboard.release( j);
        
      j = EEPROM.read( (2*i) + 1);     // mode code
      if( j != 0)
        Mouse.release( j);
        
      // Even though the switch is pressed, make it inactive.
      // The new code will be used the next time the switches are checked.
      active[i] = false;
    }

    // Write the new codes to EEPROM.
    EEPROM.write( (2*i) + 0, keyboardCode);
    EEPROM.write( (2*i) + 1, mouseCode);
    break;
    
  case 'I':
    // Test for command 'INIT'
    // The command is 'INIT' and not just 'I'.
    // This is to avoid accidential initializing
    // with bad serial data (for example if the baudrate was wrong).
    // Wait for the hole command to be in the receive buffer.
    delay(100);
    buffer[0] = 'I';
    buffer[1] = Serial.read();
    buffer[2] = Serial.read();
    buffer[3] = Serial.read();
    buffer[4] = '\0';
    if( strcmp( buffer, "INIT") == 0)
    {
      // reset the values for the switches
      // First switch will be 'A', second switch 'B' and so on.
      // The mouse code is not used, it is set to 0.
      for( i=0; i<NUMBER_SWITCHES; i++)
      {
        EEPROM.write( (2*i) + 0, 'A' + i);       // set keyboard code
        EEPROM.write( (2*i) + 1, 0);              // set mouse code
      }
        
      // Assume no switches are active
      for( i=0; i<NUMBER_SWITCHES; i++)
        active[i] = false;
        
      // Nothing is returned to the serial port.
      // Because I assume that it is mostly used with a command line script.
      // To know that the initialization has succeeded,
      // the foot switches can be pressed one by one.
    }
    break;
    
  case 'W':
    // Test for command 'WHO'
    // This can be used to identify that the footswitches
    // are connected to the serial COM port.
    // Wait for the whole command te be in the receive buffer.
    delay(100);
    buffer[0] = 'W';
    buffer[1] = Serial.read();
    buffer[2] = Serial.read();
    buffer[3] = '\0';
    if( strcmp( buffer, "WHO") == 0)
    {
      // return string for identification
      Serial.println( F("FOOTSWITCHES"));
    }
    break;

  case '?':
    // Command '?'
    // A single character which can be used in the serial monitor.
    // It shows information.
    Serial.println(F("Foot Switches"));
    Serial.println(F("February 2013"));
    Serial.println(F("Compilation date: " __DATE__));
    Serial.println(F("Compilation time: " __TIME__));
    Serial.println(F("9600,8,N,1"));
    Serial.println(F("Usage:"));
    Serial.println(F("  #xKKMM\\r\\n"));
    Serial.println(F("      #, The '#' is used as a start character"));
    Serial.println(F("      x, The switch number, starting from 0"));
    Serial.println(F("      KK, The keyboard code as 2 hexadecimal numbers."));
    Serial.println(F("          A code from the ASCII table,"));
    Serial.println(F("          or a special key, see USBAPI.h"));
    Serial.println(F("          Set to 00 if not used"));
    Serial.println(F("      MM, The mouse code as 2 hexadecimal numbers."));
    Serial.println(F("          01 is left mouse button"));
    Serial.println(F("          02 is right mouse button"));
    Serial.println(F("          04 is middle mouse button"));
    Serial.println(F("          Set to 00 if not used"));
    Serial.println(F("      \\r\\n, Any trailing \\r\\n is ignored."));
    Serial.println(F("    Examples:"));
    Serial.println(F("      #0DA00   set switch 0 to cursor up"));
    Serial.println(F("      #10001   set switch 1 to left mouse click"));
    Serial.println(F("  ?    : Show this info"));
    Serial.println(F("  INIT : Initialize codes to 'A', 'B', ..."));
    Serial.println(F("  WHO  : Returns \"FOOTSWITCHES\""));

  default:
    break;
  }

  return( 0);
}


void ProcessSwitches( void)
{
  int i, j, p;

  for( i=0; i<NUMBER_SWITCHES; i++)
  {
    // If the foot switch is pressed, the input is LOW.
    // So LOW is active.
    p = digitalRead( pinSwitch[i]);
    if (!active[i] && p == LOW)
    {
      // Switch has been pressed.
      // Send the codes from the EEPROM.
      j = EEPROM.read( (2*i) + 0);         // keyboard code
      if( j != 0)
        Keyboard.press( j);
    
      j = EEPROM.read( (2*i) + 1);         // mouse code
      if( j != 0)
        Mouse.press( j);

      active[i] = true;                    // remember switch is pressed
      delay(20);                           // for debounce
    }
    else if (active[i] && p == HIGH)
    {
      // Switch has been released.
      // First the mouse button is released, and after that the keyboard.
      // That is the best order for example for Ctrl + mouse click.

      j = EEPROM.read( (2*i) + 1);         // read mouse code
      if( j != 0)
        Mouse.release( j);

      j = EEPROM.read( (2*i) + 0);         // read keyboard code
      if( j != 0)
        Keyboard.release( j);

      active[i] = false;
      delay(20);                           // for debounce
    }
  }
}