Control de teclado y ratón con aplicación Android a través de Arduino (8 / 10 paso)

Paso 8: El proceso de bosquejo

El papel del esbozo del proceso es recibir caracteres del Arduino (via USB) y actuar en consecuencia. Por ejemplo, cuando recibe la letra 'L' (debajo de la ~ bandera, que señalado para el modo de ratón), se mueve el cursor del ratón del ordenador a la eft [L] por un cierto número de píxeles. Eres capaz de controlar la funcionalidad de teclado y ratón de la computadora en el proceso utilizando la clase de Robot.

NOTAS:
* En la función setup(), asegúrese de cambiar "[0]" en la línea "myPort = serie nueva (este, Serial.list() [0], 57600);" para el número apropiado, significa puerto serie/USB que tienes conectado a Arduino. Para determinar este número, ejecute el bosquejo del proceso una vez y verás un listado de los los puertos serie en el panel salida. Cambie el código para reflejar su elección.

El código fuente:

Import processing.serial.*;
Import java.awt.AWTException;
Import java.awt.Robot;
importación java.awt.event.KeyEvent;
Import java.awt.event.InputEvent;

Serie myPort;
char a = '0';
Robot de robot;
int x = 720;
int y = 450;
amt int = 10;
Boolean isBackspace = false;
Boolean isKeyboard = false;
Boolean isMouse = false;

void setup()
{
trate de {}
robot = Robot() nuevo;
} catch (AWTException e) {}
e.printStackTrace();
}
println(serial.List());
myPort = serie nueva (este, Serial.list() [0], 57600);
}

void draw()
{

robot.setAutoDelay(40);
robot.setAutoWaitForIdle(true);

if(myPort.Available() > 0)
{

en = myPort.readChar();

determinar el teclado o el ratón
Si (en == ''')
{
isBackspace = true;
isKeyboard = false;
isMouse = false;
}
else if (en == ' ^')
{
isKeyboard = true;
isBackspace = false;
isMouse = false;
}
else if (en == ' ~') {}
isMouse = true;
isBackspace = false;
isKeyboard = false;
}

actuar como retroceso
if(isBackspace)
{
Si (en == 'B') type(KeyEvent.VK_BACK_SPACE);
}
actuar como teclado
if(isKeyboard) más
{
Switch(in)
{
caso 'A':
typeCaps(KeyEvent.VK_A);
rotura;
caso 'B':
typeCaps(KeyEvent.VK_B);
rotura;
caso 'C':
typeCaps(KeyEvent.VK_C);
rotura;
caso sería ':
typeCaps(KeyEvent.VK_D);
rotura;
caso 'E':
typeCaps(KeyEvent.VK_E);
rotura;
caso 'F':
typeCaps(KeyEvent.VK_F);
rotura;
caso 'G':
typeCaps(KeyEvent.VK_G);
rotura;
caso 'H':
typeCaps(KeyEvent.VK_H);
rotura;
caso 'I':
typeCaps(KeyEvent.VK_I);
rotura;
caso 'J':
typeCaps(KeyEvent.VK_J);
rotura;
caso 'K':
typeCaps(KeyEvent.VK_K);
rotura;
caso 'L':
typeCaps(KeyEvent.VK_L);
rotura;
caso soy ':
typeCaps(KeyEvent.VK_M);
rotura;
caso ' n ':
typeCaps(KeyEvent.VK_N);
rotura;
caso ' o ':
typeCaps(KeyEvent.VK_O);
rotura;
caso 'P':
typeCaps(KeyEvent.VK_P);
rotura;
caso 'Q':
typeCaps(KeyEvent.VK_Q);
rotura;
caso 'R':
typeCaps(KeyEvent.VK_R);
rotura;
de caso ':
typeCaps(KeyEvent.VK_S);
rotura;
caso ' t ':
typeCaps(KeyEvent.VK_T);
rotura;
caso 'U':
typeCaps(KeyEvent.VK_U);
rotura;
caso 'V':
typeCaps(KeyEvent.VK_V);
rotura;
caso 'W':
typeCaps(KeyEvent.VK_W);
rotura;
caso 'X':
typeCaps(KeyEvent.VK_X);
rotura;
caso 'Y':
typeCaps(KeyEvent.VK_Y);
rotura;
caso 'Z':
typeCaps(KeyEvent.VK_Z);
rotura;
caso 'a':
Type(KeyEvent.VK_A);
rotura;
caso 'b':
Type(KeyEvent.VK_B);
rotura;
caso 'c':
Type(KeyEvent.VK_C);
rotura;
caso sería ':
Type(KeyEvent.VK_D);
rotura;
caso 'e':
Type(KeyEvent.VK_E);
rotura;
caso 'f':
Type(KeyEvent.VK_F);
rotura;
caso 'g':
Type(KeyEvent.VK_G);
rotura;
caso 'h':
Type(KeyEvent.VK_H);
rotura;
caso 'i':
Type(KeyEvent.VK_I);
rotura;
caso 'j':
Type(KeyEvent.VK_J);
rotura;
caso 'k':
Type(KeyEvent.VK_K);
rotura;
caso 'l':
Type(KeyEvent.VK_L);
rotura;
caso soy ':
Type(KeyEvent.VK_M);
rotura;
caso ' n ':
Type(KeyEvent.VK_N);
rotura;
caso ' o ':
Type(KeyEvent.VK_O);
rotura;
caso 'p':
Type(KeyEvent.VK_P);
rotura;
caso 'q':
Type(KeyEvent.VK_Q);
rotura;
caso 'r':
Type(KeyEvent.VK_R);
rotura;
de caso ':
Type(KeyEvent.VK_S);
rotura;
caso ' t ':
Type(KeyEvent.VK_T);
rotura;
caso 'u':
Type(KeyEvent.VK_U);
rotura;
caso 'v':
Type(KeyEvent.VK_V);
rotura;
caso 'w':
Type(KeyEvent.VK_W);
rotura;
caso 'x':
Type(KeyEvent.VK_X);
rotura;
caso 'y':
Type(KeyEvent.VK_Y);
rotura;
caso 'z':
Type(KeyEvent.VK_Z);
rotura;
caso '0':
Type(KeyEvent.VK_0);
rotura;
caso '1':
Type(KeyEvent.VK_1);
rotura;
caso '2':
Type(KeyEvent.VK_2);
rotura;
Case '3':
Type(KeyEvent.VK_3);
rotura;
caso '4':
Type(KeyEvent.VK_4);
rotura;
caso '5':
Type(KeyEvent.VK_5);
rotura;
caso '6':
Type(KeyEvent.VK_6);
rotura;
caso '7':
Type(KeyEvent.VK_7);
rotura;
caso '8':
Type(KeyEvent.VK_8);
rotura;
caso '9':
Type(KeyEvent.VK_9);
rotura;
caso ' ':
Type(KeyEvent.VK_SPACE);
rotura;
caso '\n':
Type(KeyEvent.VK_ENTER);
rotura;
caso '.':
Type(KeyEvent.VK_PERIOD);
rotura;
caso ',':
Type(KeyEvent.VK_COMMA);
rotura;
caso '/':
Type(KeyEvent.VK_SLASH);
rotura;
caso ';':
Type(KeyEvent.VK_SEMICOLON);
rotura;
caso de '=':
Type(KeyEvent.VK_EQUALS);
rotura;
caso '-':
Type(KeyEvent.VK_MINUS);
rotura;

por defecto:
rotura;
}
}
actuar como un ratón
if(isMouse) más
{
Switch(in)
{
caso 'Z':
robot.mousePress(InputEvent.BUTTON1_MASK);
Delay(100);
robot.mouseRelease(InputEvent.BUTTON1_MASK);
rotura;
caso 'X':
robot.mousePress(InputEvent.BUTTON3_MASK);
Delay(100);
robot.mouseRelease(InputEvent.BUTTON3_MASK);
rotura;
caso 'U':
Si (y > 0) y = amt;
robot.mouseMove (x, y);
rotura;
caso sería ':
Si (y < 900) y += amt;
robot.mouseMove (x, y);
rotura;
caso 'L':
if(x > 0) x-= amt;
robot.mouseMove (x, y);
rotura;
caso 'R':
if(x < 1440) x += amt;
robot.mouseMove (x, y);
rotura;
caso 'P':
Si (amt < 500) amt += 5;
rotura;
caso soy ':
Si amt (amt > 5)-= 5;
else if (amt > 1) amt-= 1;
rotura;

por defecto:
rotura;
}
}
}
}

tipo void (int k)
{
robot.keyPress(k);
robot.keyRelease(k);
}
void typeCaps(int k)
{
robot.keyPress(KeyEvent.VK_SHIFT);
robot.keyPress(k);
robot.keyRelease(k);
robot.keyRelease(KeyEvent.VK_SHIFT);
}