{"id":1852,"date":"2014-06-22T21:54:00","date_gmt":"2014-06-23T02:54:00","guid":{"rendered":"http:\/\/linuxitos.com\/main\/recibir-datos-desde-arduino-utilizando-una-interfaz-en-java\/"},"modified":"2014-06-22T21:54:00","modified_gmt":"2014-06-23T02:54:00","slug":"recibir-datos-desde-arduino-utilizando-una-interfaz-en-java","status":"publish","type":"post","link":"https:\/\/linuxitos.com\/main\/recibir-datos-desde-arduino-utilizando-una-interfaz-en-java\/","title":{"rendered":"Recibir datos desde arduino utilizando una interfaz en java"},"content":{"rendered":"
Ejecutar jbuttons desde arduino al presionar botones f\u00edsicos.<\/b><\/span><\/div>\n

<\/span><\/div>\n
Recientemente desarroll\u00e9 una aplicaci\u00f3n utilizando arduino para manipular una interfaz gr\u00e1fica a trav\u00e9s de botones f\u00edsicos conectados a arduino. La interfaz gr\u00e1fica fue hecha en java, utilizando netbeans 8.0 en fedora 20.<\/span><\/div>\n

<\/span><\/div>\n
Fue la primera vez que utilic\u00e9 arduino, adem\u00e1s tambi\u00e9n fue la primera vez que conect\u00e9 arduino con java.<\/span><\/div>\n
Cuando se usa linux, por lo general se complica lo suficiente al querer ejecutar un programa, la mayor\u00eda de las veces es por cuestiones de permisos de archivos o permisos de ejecuci\u00f3n de archivos, as\u00ed tambi\u00e9n como los permisos que tenga el directorio donde est\u00e1 almacenado dicho ejecutable.<\/span><\/div>\n

<\/span><\/div>\n
Antes de comenzar es necesario que tengan instalado:<\/span><\/div>\n

<\/p>\n

  • Java<\/b><\/span><\/span><\/li>\n
  • Arduino<\/b><\/span><\/span><\/li>\n
  • Librerias de arduino<\/b><\/span><\/span><\/li>\n
  • Netbeans 7.4 O superior<\/b><\/span><\/span><\/li>\n

    <\/p>\n

    <\/div>\n
    Tomar\u00e9 en cuenta que ya tienen instalado los paquetes necesarios y continuar\u00e9 con la explicaci\u00f3n de la peque\u00f1a aplicaci\u00f3n que he creado.<\/span><\/div>\n
    Se utiliz\u00f3 la tarjeta arduino uno.<\/b> <\/span><\/div>\n

    <\/span><\/div>\n
    Descripci\u00f3n del proyecto: crear una interfaz en java utilizando jframe con 4 botones, cada bot\u00f3n realizar\u00e1 un determinada acci\u00f3n. Realizar un peque\u00f1o tablero con 4 pushbuttons conectados a arduino. La idea es que cuando se presione un bot\u00f3n en el tablero se ejecute la acci\u00f3n de un bot\u00f3n en la interfaz desarrollada en java. De tal modo que el dispositivo de interacci\u00f3n sea el tablero con botones.<\/b><\/span><\/div>\n

    <\/b><\/span><\/div>\n
    Realizaci\u00f3n:<\/b><\/span><\/div>\n
    Primero se crear\u00e1 la interfaz gr\u00e1fica, lo dejar\u00e9 a su criterio, es un jframe que debe de tener 4 botones.<\/span><\/div>\n
    <\/a><\/div>\n

    <\/span><\/div>\n
    Pueden crear una interfaz parecida a la imagen de arriba o hacer una que les convenga.<\/span><\/div>\n
    Los botones f\u00edsicos que estar\u00e1n conectados a arduino pueden dise\u00f1arlos o colocarlos en un protoboard.<\/span>
    El circuito es el siguiente:<\/span><\/p>\n
    <\/a><\/div>\n


    <\/span>
    <\/span><\/div>\n

    El programa que estar\u00e1 codificado en arduino es el siguiente:<\/span>
    \/\/se declaran los pines de entrada que se usaran<\/span>
    const int buttonPin = 2;     \/\/Se reserva el numero de pin de entrada<\/span>
    const int buttonPin2 = 3;    \/\/Se reserva el numero de pin de entrada<\/span>
    const int buttonPin3 = 4;    \/\/Se reserva el numero de pin de entrada<\/span>
    const int buttonPin4 = 5;    \/\/Se reserva el numero de pin de entrada<\/span>

    <\/span>const int ledPin =  12;      \/\/Se reserva el numero de pin de entrada<\/span>
    const int ledPin2 =  11;     \/\/Se reserva el numero de pin de entrada<\/span>
    const int ledPin3 =  10;     \/\/Se reserva el numero de pin de entrada<\/span>
    const int ledPin4 =  9;      \/\/Se reserva el numero de pin de entrada<\/span>
    \/\/variables que cambian de valor durante la ejecucion<\/span>
    int buttonState = 0;         \/\/variable que almacena el valor del estado del pin de entrada buttonPin<\/span>
    int buttonState2 = 0;        \/\/variable que almacena el valor del estado del pin de entrada buttonPin2<\/span>
    int buttonState3 = 0;        \/\/variable que almacena el valor del estado del pin de entrada buttonPin3<\/span>
    int buttonState4 = 0;        \/\/variable que almacena el valor del estado del pin de entrada buttonPin4<\/span>

    <\/span>int buttonStateFinal1 = 0;         \/\/variable que almacena el valor del estado del pin de entrada buttonPin<\/span>
    int buttonStateFinal2 = 0;        \/\/variable que almacena el valor del estado del pin de entrada buttonPin2<\/span>
    int buttonStateFinal3 = 0;        \/\/variable que almacena el valor del estado del pin de entrada buttonPin3<\/span>
    int buttonStateFinal4 = 0;        \/\/variable que almacena el valor del estado del pin de entrada buttonPin4<\/span>

    <\/span>int sensorPin = A0;          \/\/entrada del sensor de ritmocardiaco se declara el pin que se usara<\/span>
    int sensorValue = 0;         \/\/variable en la que se almacena el valor leido del pin de entrada del sensor<\/span>

    <\/span>int leerDatos=0; \/\/variable para indicar si se continua leyendo o no;<\/span>
    void setup(){<\/span>
      \/\/Serial.begin(115200); \/\/Open the serial port<\/span>
      Serial.begin(9600); \/\/se abre el puerto serial<\/span>
      \/\/se inicializan los pines salida en caso de que se necesiten<\/span>
      pinMode(ledPin, OUTPUT);<\/span>
      pinMode(ledPin2, OUTPUT);<\/span>
      pinMode(ledPin3, OUTPUT);<\/span>
      pinMode(ledPin4, OUTPUT);<\/span>
      \/\/se inicializan los pines de entrada y que seran los que se tienen que leer<\/span>
      \/\/para saber cual es estado de cada boton<\/span>
      pinMode(buttonPin, INPUT);<\/span>
      pinMode(buttonPin2, INPUT);<\/span>
      pinMode(buttonPin3, INPUT);<\/span>
      pinMode(buttonPin4, INPUT);<\/span>
    }<\/span>

    <\/span>void loop(){<\/span>
        \/\/leerDatos = Serial.read();<\/span>
        \/\/if(leerDatos==’1′){<\/span>
          \/\/ se leen los estados de cada uno de los pines de entrada<\/span>
          buttonState = digitalRead(buttonPin);<\/span>
          buttonState2 = digitalRead(buttonPin2);<\/span>
          buttonState3 = digitalRead(buttonPin3);<\/span>
          buttonState4 = digitalRead(buttonPin4);<\/span>
          \/\/sensorValue = analogRead(sensorPin);<\/span>
          \/\/ verifica el valor leido de cada pin<\/span>
          \/\/ si el valor es 1 los leds se encienden, en caso contrario<\/span>
          \/\/ el led continua apagado<\/span>
          if(buttonState == HIGH){<\/span>
            digitalWrite(ledPin4, HIGH);<\/span>
            buttonStateFinal1=1;<\/span>
          }else{<\/span>
            digitalWrite(ledPin4, LOW);<\/span>
            buttonStateFinal1=0;<\/span>
          }<\/span>
          if(buttonState2 == HIGH){<\/span>
            digitalWrite(ledPin3, HIGH);<\/span>
            buttonStateFinal2=2;<\/span>
          }else{<\/span>
            digitalWrite(ledPin3, LOW);<\/span>
            buttonStateFinal2=0;<\/span>
          }<\/span>
          if(buttonState3 == HIGH){<\/span>
            digitalWrite(ledPin2, HIGH);<\/span>
            buttonStateFinal3=3;<\/span>
          }else{<\/span>
            digitalWrite(ledPin2, LOW);<\/span>
            buttonStateFinal3=0;<\/span>
          }<\/span>
          if(buttonState4 == HIGH){<\/span>
            digitalWrite(ledPin, HIGH);<\/span>
            buttonStateFinal4=4;<\/span>
          }else{<\/span>
            digitalWrite(ledPin, LOW);<\/span>
            buttonStateFinal4=0;<\/span>
          }<\/span>
          \/\/se imprimen los valores leidos a pantalla, este proceso es necesario<\/span>
          \/\/de aqui depende para que desde java se puedan leer dichos valores<\/span>
          Serial.println(buttonStateFinal1);<\/span>
          Serial.println(buttonStateFinal2);<\/span>
          Serial.println(buttonStateFinal3);<\/span>
          Serial.println(buttonStateFinal4);<\/span>
          \/\/Serial.println(sensorValue);<\/span>
          \/\/el programa se espera un tiempo de 100 milisegundos antes de volver<\/span>
          \/\/a realizar una lectura, no es tan necesario el retardo, para<\/span>
          \/\/para que java no se le haga pesado, es necesario un retardo<\/span>
        \/\/}<\/span>
        delay(100); \/*detiene el programa por 100 milisegundos antes de volver a leer los puerto*\/<\/span>
    <\/span>
    }<\/span><\/div>\n

    <\/span>El c\u00f3digo de arduino parece mucho, pero las impresiones son m\u00e1s bien para saber qu\u00e9 est\u00e1 pasando en cada momento, as\u00ed que descuiden, dependiendo de la necesidad que tengan, as\u00ed pueden ir modificando dicho c\u00f3digo.<\/span>

    <\/span>Despu\u00e9s de que su c\u00f3digo ya est\u00e9 codificado en la tarjeta, procedemos a crear la aplicaci\u00f3n en java.<\/span>

    <\/span>La clase principal, que se mostr\u00f3 en la primera imagen lleva el siguiente c\u00f3digo. En realidad pueden crear s\u00f3lo un jframe con 4 botones o los que consideren necesarios y listo.<\/span>

    <\/span>\/*<\/span>
     * La clase VentanaJuego que extiende jframe, contiene el juego principal,<\/span>
        es decir, \u00e9sta clase es donde se muesra en s\u00ed todo el proceso del juego.<\/span>
     *\/<\/span>

    <\/span>package ventanasScoop;<\/span>

    <\/span>import java.util.logging.Level;<\/span>
    import java.util.logging.Logger;<\/span>

    <\/span>\/**<\/span>
     *<\/span>
     * @author neo Jes\u00fas Fernando Merino Merino<\/span>
     *\/<\/span>
    public class VentanaJuego extends javax.swing.JFrame implements  Runnable{<\/span>

    <\/span>    \/**<\/span>
         * Se crea un objeto de tipo VentanaJuego para que reciba el objeto que le<\/span>
         * envian de la interfaz iniciarScoop, dicho objeto.<\/span>
         * Es aqu\u00ed donde se crea el objeto que se usar\u00e1 para leer los datos desde arduino<\/span>
         *\/<\/span>
        \/*Objeto creado para manipular la interfaz del juego scoop*\/<\/span>
        private VentanaJuego jugarJuego;<\/span>
        \/*Se crea el objeto de tipo DatosJugador dicho objeto almacenar\u00e1 toda la<\/span>
        informaci\u00f3n necesari del jugador que inice sesi\u00f3n para jugar*\/<\/span>
        private DatosJugador datosJugador;<\/span>
        \/*variable que almacena la interfaz de inicio de sesi\u00f3n*\/<\/span>
        private iniciarScoop inicioSesion;<\/span>
        \/*variable que se usa para iniciar el sensado de la tarjeta arduino<\/span>
        b\u00e1sicamente es un hilo que se lanza, y que s\u00f3lo se consultan los datos<\/span>
        almacenados en un vector declarado en dicha clase*\/<\/span>
        \/\/LecturaFromArduino lectArduino=new LecturaFromArduino();<\/span>
        private LecturaFromArduino lectArdReciv;<\/span>
        <\/span>
        \/*variable que debe de estar activada para poder realizar validaciones cuando<\/span>
        el usuario est\u00e9 sobre esta ventana*\/<\/span>
        private boolean permitBotArdVentJueg=true;<\/span>
        <\/span>
        \/*variable que almacena el hilo que se pone en ejecuci\u00f3n para relizar la validadi\u00f3n<\/span>
        de los datos que se reciben al presionar un bot\u00f3n en el tapete*\/<\/span>
        Thread obtDatArd;<\/span>
        <\/span>
        public VentanaJuego() {<\/span>
            initComponents();<\/span>
        }<\/span>
        public VentanaJuego(VentanaJuego ventJuego,DatosJugador datJugador) {<\/span>
            initComponents();<\/span>
        }<\/span>
        public VentanaJuego(iniciarScoop inicio,DatosJugador datJugador) {<\/span>
            \/*constructor que recibe el objeto de inicio de sesi\u00f3n y los datos del jugador*\/<\/span>
            initComponents();<\/span>
            setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);<\/span>
            setLocationRelativeTo(null);<\/span>
            setDatosJugador(datJugador);<\/span>
            setInicioSesion(inicio);<\/span>
            visulizarNomJugadorVentana();<\/span>
        }<\/span>
        public VentanaJuego(iniciarScoop inicio,DatosJugador datJugador, LecturaFromArduino lectArd) {<\/span>
            \/*constructor que recibe el objeto de inicio de sesi\u00f3n, los datos del jugador<\/span>
            y el objeto que inicia la lectura desde arduino, para poder acceder al m\u00e9todo<\/span>
            que retorna el arreglo de datos obtenidos desde arduino*\/<\/span>
            initComponents();<\/span>
            setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);<\/span>
            setLocationRelativeTo(null);<\/span>
            setDatosJugador(datJugador);<\/span>
            setInicioSesion(inicio);<\/span>
            visulizarNomJugadorVentana();<\/span>
            setLectArduReciv(lectArd);<\/span><\/span>
            iniciaValidBotArd();<\/span>
        }<\/span>
        public void ninioONinia(DatosJugador datosJugador){<\/span>
            \/*m\u00e9todo que valida si el usuario que a accedio es ni\u00f1o o ni\u00f1a, para modificar<\/span>
            el color de los \u00edconos*\/   <\/span>
        }<\/span>
        public final void visulizarNomJugadorVentana(){<\/span>
            \/*se establece el nombre del jugador en el jlabel*\/<\/span>
            jlDatosJugador.setText(\u00abBienvenido: \u00ab+datosJugador.getNomJugador());<\/span>
        }<\/span>
        \/*inicia declaraci\u00f3n de m\u00e9todos de set y get de los atributos de esta interfaz*\/<\/span>
        public void setVentanaJugador(VentanaJuego ventana){<\/span>
            jugarJuego=ventana;<\/span>
        }<\/span>
        public final void setDatosJugador(DatosJugador datos){<\/span>
            datosJugador=datos;<\/span>
        }<\/span>
        public final void setInicioSesion(iniciarScoop inicio){<\/span>
            inicioSesion=inicio;<\/span>
        }<\/span>
        public void setPermitBotArdVentJue(boolean permitir){<\/span>
            permitBotArdVentJueg=permitir;<\/span>
        }<\/span>
        public final void setLectArduReciv(LecturaFromArduino let){<\/span>
            \/*inicializa el objeto recibido del sensado desde arudino*\/<\/span>
            lectArdReciv=let;<\/span>
        }<\/span>
        public boolean getPermitBotArdVentJue(){<\/span>
            return permitBotArdVentJueg;<\/span>
        }<\/span>
        \/*finaliza declaraci\u00f3n de m\u00e9todos de set y get de los atributos de esta interfaz*\/<\/span>
        <\/span>
        public void detenerValidBotVentJuego(boolean  estado){<\/span><\/span>
            \/*detiene o reanuda la valici\u00f3n de los resultados que se obtienen de los<\/span>
            hilos, dependiendo si el usuario se encuentra en la ventanaJuego*\/<\/span>
            permitBotArdVentJueg=estado;<\/span>
        <\/span>}<\/span>
        public final void iniciaValidBotArd(){<\/span><\/span>
            obtDatArd=new Thread(this);<\/span>
            obtDatArd.start();<\/span>
        }<\/span> <\/span>             <\/span>

    <\/span>    private void jbSalirActionPerformed(java.awt.event.ActionEvent evt) {                                        <\/span>
            new SalirJuego(this, true,datosJugador,inicioSesion,lectArdReciv).setVisible(true);<\/span>
        }                                       <\/span>
        <\/span>

    <\/span>    \/\/ Variables declaration – do not modify                     <\/span>
        private javax.swing.JButton jbAyuda;<\/span>
        private javax.swing.JButton jbIniciar;<\/span>
        private javax.swing.JButton jbRanking;<\/span>
        private javax.swing.JButton jbSalir;<\/span>
        private javax.swing.JLabel jlDatosJugador;<\/span>
        private javax.swing.JLabel jlTutorial;<\/span>
        private javax.swing.JPanel jpBackJuego;<\/span>
        \/\/ End of variables declaration                   <\/span>

    <\/span>    @Override<\/span><\/span>
        public void run() {<\/span>
            \/\/throw new UnsupportedOperationException(\u00abNot supported yet.\u00bb); \/\/To change body of generated methods, choose Tools | Templates.<\/span>
            \/*m\u00e9todo que ejecuta acciones en la ventana de men\u00fa del jugador, de acuerdo<\/span>
            a los datos que se reciben de los botones que se presionan desde el tapete*\/<\/span>
            String [] datosArd;<\/span>
            while (permitBotArdVentJueg) {            <\/span>
                datosArd = lectArdReciv.getDatRecArduino();<\/span>
                \/\/System.out.println(\u00abDatos de arduino: \u00ab+datosArd[0]+\u00bb  \u00ab+datosArd[1]+\u00bb  \u00ab+datosArd[2]+\u00bb  \u00ab+datosArd[3]);<\/span>
                System.out.println(\u00abDatos de arduino: \u00ab+datosArd[0]);<\/span>
                \/*proceso de validar qu\u00e9 n\u00famero de bot\u00f3n se ha presionado*\/<\/span>
                switch(datosArd[0]){<\/span>
                    case \u00ab1\u00bb:<\/span>
                        jbIniciar.doClick();<\/span>
                        break;<\/span>
                    case \u00ab2\u00bb:<\/span>
                        jbRanking.doClick();<\/span>
                        break;<\/span>
                    case \u00ab3\u00bb:<\/span>
                        jbAyuda.doClick();<\/span>
                        break;<\/span>
                    case \u00ab4\u00bb:<\/span>
                        jbSalir.doClick();<\/span>
                        break;<\/span>
                    default:<\/span>
                        break;<\/span>
                }<\/span>
                try {<\/span>
                    Thread.sleep(100);<\/span>
                } catch (InterruptedException ex) {<\/span>
                    Logger.getLogger(VentanaJuego.class.getName()).log(Level.SEVERE, null, ex);<\/span>
                }<\/span>
            }<\/span>
        }<\/span>

    <\/span><\/span>
    }<\/span>

    <\/span>B\u00e1sicamente las funciones que est\u00e1n de azul, son las m\u00e1s importantes.<\/span>
    En primera se inicia un un hilo que crea un objeto de tipo zyncronized, el cual lee constantemente desde el puerto que est\u00e9 conectado arduino, luego valida qu\u00e9 bot\u00f3n fue el que se puls\u00f3, de acuerdo al n\u00famero que se recibe de arduino.<\/span>
    Y lo que se hace es, que se ejecuta el doclic() del bot\u00f3n que se necesario. Y listo.<\/span>
    La clase de arduino es la siguiente:<\/span>
    package ventanasScoop;<\/span>

    <\/span>import gnu.io.CommPortIdentifier;<\/span>
    import gnu.io.PortInUseException;<\/span>
    import gnu.io.SerialPort;<\/span>
    import gnu.io.SerialPortEvent;<\/span>
    import gnu.io.SerialPortEventListener;<\/span>
    import gnu.io.UnsupportedCommOperationException;<\/span>
    import static java.awt.image.ImageObserver.ERROR;<\/span>
    import java.io.BufferedReader;<\/span>
    import java.io.IOException;<\/span>
    import java.io.InputStreamReader;<\/span>
    import java.io.OutputStream;<\/span>
    import java.util.Enumeration;<\/span>
    import java.util.TooManyListenersException;<\/span>

    <\/span>\/**<\/span>
     *<\/span>
     * @author neo Jesus Fernando Merino<\/span>
     *\/<\/span>
    public class LecturaFromArduino implements SerialPortEventListener{<\/span>
        private OutputStream Output = null;<\/span>
        private BufferedReader Input = null;<\/span>
        private SerialPort serialPort;<\/span>
        private String[] inputLine;<\/span>
        private final String PORT_NAME = \u00ab\/dev\/ttyUSB0\u00bb;<\/span>
        private static final int TIME_OUT = 110;<\/span>
        private static final int DATA_RATE = 9600;<\/span>
        int cont=0;<\/span>

    <\/span>    public LecturaFromArduino() {<\/span>
            this.inputLine = new String[5];<\/span>
        }<\/span>
        public String[] getDatRecArduino(){<\/span>
            \/*retorna el arreglo que contien los datos que se reciben desde Arduino*\/<\/span>
            return inputLine;<\/span>
        }<\/span>
        @Override<\/span>
        public synchronized void serialEvent(SerialPortEvent oEvent) {<\/span>
            if (oEvent.getEventType() == SerialPortEvent.DATA_AVAILABLE){<\/span>
                try{<\/span>
                    inputLine[0]=Input.readLine();<\/span>
                    \/\/inputLine[1]=Input.readLine();<\/span>
                    \/\/inputLine[2]=Input.readLine();<\/span>
                    \/\/inputLine[3]=Input.readLine();<\/span>
                    \/\/System.out.println(\u00abDatos recibidos: \u00ab+inputLine[0]+\u00bb : \u00ab+inputLine[1]+\u00bb : \u00ab+inputLine[2]+\u00bb : \u00ab+inputLine[3]);<\/span>
                }catch (IOException e){<\/span>
                    System.err.println(\u00abErorr funci\u00f3n serialEvent: \u00ab+e.getMessage());<\/span>
                }<\/span>
            }<\/span>
        }<\/span>
        <\/span>
        public void ArduinoConnection() {<\/span>
            CommPortIdentifier portId = null;<\/span>
            Enumeration portEnum = CommPortIdentifier.getPortIdentifiers();<\/span>
            while (portEnum.hasMoreElements()) {<\/span>
                CommPortIdentifier currPortId = (CommPortIdentifier) portEnum.nextElement();<\/span>
                if (PORT_NAME.equals(currPortId.getName())) {<\/span>
                    portId = currPortId;<\/span>
                    break;<\/span>
                }<\/span>
            }<\/span>
            if (portId == null) {<\/span>
                System.exit(ERROR);<\/span>
                return;<\/span>
            }<\/span>
            try {<\/span>
                serialPort = (SerialPort) portId.open(this.getClass().getName(), TIME_OUT);<\/span>
                serialPort.setSerialPortParams(DATA_RATE,<\/span>
                        SerialPort.DATABITS_8,<\/span>
                        SerialPort.STOPBITS_1, \/*SerialPort.STOPBITS_1*\/<\/span>
                        SerialPort.PARITY_NONE);<\/span>
                Output = serialPort.getOutputStream();<\/span>
                Input = new BufferedReader(new InputStreamReader(serialPort.getInputStream()));<\/span>
                serialPort.addEventListener(this);<\/span>
                serialPort.notifyOnDataAvailable(true);<\/span>
            } catch (PortInUseException | UnsupportedCommOperationException | IOException | TooManyListenersException e) {<\/span>
                System.err.println(\u00abError ArduinoConnection: \u00ab+e.getMessage());<\/span>
            }<\/span>
        }<\/span>
        private void EnviarDatos(String data) {<\/span>
            try {<\/span>
                Output.write(data.getBytes());<\/span>
            } catch (IOException e) {<\/span>
                System.exit(ERROR);<\/span>
            }<\/span>
        }<\/span>

    <\/span>    private void RecibirDatos() throws IOException {<\/span>
            int Output1;<\/span>
            Output1 = Integer.parseInt(Input.readLine());<\/span>
            cont= Integer.parseInt(Input.readLine());<\/span>
            System.out.println(\u00abOuput1: \u00ab+Output1 +\u00bb valor recibido: \u00ab+cont);<\/span>
        }<\/span>
    <\/span>
    }<\/span>

    <\/span>Ojo, necesitar\u00e1n la librer\u00eda librxtxSerial.so, tambi\u00e9n el jar RXTXcomm.jar, y lo colocan en la carpeta lib de su proyecto, y pues claro importan los jar para que funcione.<\/span>
    Adem\u00e1s en la pesta\u00f1a propiedades de su proyecto deben especificar la ruta en donde se encuentra la <\/span>librer\u00eda librxtxSerial.so en la secci\u00f3n run en la descripci\u00f3n VM options: de preferencia muevan la librer\u00eda <\/span>librxtxSerial.so a la carptea lib de su proyecto, y coloquen la siguiente ruta.<\/span>

    <\/span>-Djava.library.path=\u00bb..\/scoopControlButtons\/lib\/\u00bb<\/span>

    <\/span>
    <\/span>Ejecutan su proyecto y deber\u00e1 funcionar, en caso de que no, por favor env\u00edenme un msj para aclarar dudas.<\/div>\n","protected":false},"excerpt":{"rendered":"

    Ejecutar jbuttons desde arduino al presionar botones f\u00edsicos. Recientemente desarroll\u00e9 una aplicaci\u00f3n utilizando arduino para manipular una interfaz gr\u00e1fica a trav\u00e9s de botones f\u00edsicos conectados a arduino. La interfaz gr\u00e1fica fue hecha en java, utilizando netbeans 8.0 en fedora 20. Fue la primera vez que utilic\u00e9 arduino, adem\u00e1s tambi\u00e9n fue la primera vez que conect\u00e9 […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1507,87,1470,446,4,1516,1518,1519,1517,1472],"tags":[],"class_list":["post-1852","post","type-post","status-publish","format-standard","hentry","category-arduino","category-gnome","category-hilos","category-java","category-linux","category-login-fedora","category-puerto-serial","category-rxtx","category-sincronizacion","category-thread"],"_links":{"self":[{"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/posts\/1852","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/comments?post=1852"}],"version-history":[{"count":0,"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/posts\/1852\/revisions"}],"wp:attachment":[{"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/media?parent=1852"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/categories?post=1852"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/linuxitos.com\/main\/wp-json\/wp\/v2\/tags?post=1852"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}