sábado, 28 de junio de 2014

Recuperar archivos de usb o hdd con foremost

¿Te ha pasado alguna ves que borras tu formateas tu unidad usb o borras tu  pendrive y por casualidad eliminas un archivo que no querías eliminar y lo necesitas recuperar?

Me imagino que sí, para ayudarte a recuperar elementos borrados te dejo este post.
Existen una gran variedad de herramientas para recuperar tus archivos borrados pero en esta ocasión hablaremos sobre foremost (forensic date recovery) se utiliza desde la linea de comandos con una sintaxis simple y corta pero efectiva.
Yo realizaré todo el proceso usando fedora. La instalación es casi lo mismo, claro tomando en cuenta la forma de instalar en cada distro linux, para windows no śe cómo sea el proceso, de modo que ahora sólo lo mostraré para distros linux.
Primero Instalaremos Foremost Abre la terminal de linux y teclea.
sudo yum -y install foremost
Ahora que tenemos Foremost instalado en nuestro equipo.
Creamos una carpeta en algun directorio, por ejemplo, documentos. Lo puedes hacer desde la terminal o ir al directorio y dar clic derecho y carpeta nueva.
Vuelve a la terminal y escribe
sudo foremost -t jpg -i /dev/sdb1 -o /home/(nombre de usuario)/Documentos/(nombre de Carpeta)
* sustituyes lo que esta entre paréntesis por tus datos.
 Descripción del comando:
-t significa tipo de archivo en esta ocasion usamos -t jpg esto significa que recuperaremos todos los archivos con extensión jpg
si quieres todo escribiremos  -t all
-i con i indicamos el lugar donde buscarlo aquí usamos  -i /dev/sdb1  solo sustituye la ruta por la de tu dispositivo para saber qué ruta es tu dispositivo, puedes usar el comando fdisk -l y te mostrará los dispositivos que estén conectados a tu computadora.
-o con esto indicamos el lugar donde guardaremos los archivos recuperados -o /home/(nombre de usuario) /(nombre de Carpeta)

También puedes realizar este proceso para recuperar datos de tu disco duro, mientras no le hayas escrito mas archivos desde que lo borraste aún están ahí.

martes, 24 de junio de 2014

Cambiar el motor de línea de comándos en fedora - linux

Cambiar el motor de línea de comándos en fedora - linux

A veces es necesario cambiar el motor de intérprete de comandos que usamos en nuestra terminal favorita, hace poco se presentó dicho problema, no sabía cómo hacerle, buscando en la web encontré  cómo hacerlo. 

Como sabemos, podemos cambiar dicho motor de intérprete  tanto para el usuario root, como para el usuario normal, para cambiarlo en el usuario normal se realiza de la siguiente manera:
Pero antes de cambiar el motor, primero visualizamos qué motor se está usando, con la siguiente línea vemos dicha información:
echo $SHELL

Mostrará un resultado parecido a éste
/bin/zsh
Ahora, para cambiarlo realizamos lo siguiente
chsh -s /bin/zsh usuario

Donde usuario es el nombre del usuario al que queremos cambiar el motor de intérprete. 
zsh es el nuevo motor, por ejemplo puede ser bash, también, depende cuál queramos.
Si lo que queremos es cambiarselo al usuario root, entonces hacemos lo siguiente
su -
chsh -s /bin/bash                              De nuevo, el bash corresponde al nuevo motor de intérpretes                            y listo, eso es todo.

domingo, 22 de junio de 2014

Qué hacer después de instalar fedora 20 "Heisenbug" con escritorio gnome?

Qué hacer después de instalar fedora 20 "Heisenbug" con escritorio gnome?

Antes de comenzar a usar gnome es necesario realizar unos ajustes al sistema, son completamente necesarios, debo aclarar que las instalaciones que se realizarán son para fedora 20 Heisenbug en el escritorio gnome en su versión 

1. Actualizar Fedora

Esto es 100% recomendable, para así evitar algún error y poder instalar todo con los paquetes mas recientes.
En alguno blogs recomiendan logearse como root, en lo particular prefiero agregarle el sudo, para instalar o realizar cambios en el sistema, en caso de ser realmente necesario, sólo entonces utilizar la cuenta de root. Así que para actualizar realicen lo siguiente:
sudo yum -y update
sudo yum -y upgrade

2. Poner a Fedora en español

sudo yum -y install system-config-language
system-config-language

3. Instalar repositorios extras

RPM Fusion es el repositorio adicional más importante (y casi obligatorio de agregar) en Fedora. Incluye gran parte de la paquetearía que Red Hat no incluye por defecto en sus distribuciones por motivos de licenciamiento o patentes, por lo que este repositorio es indispensable para, por ejemplo, instalar los códecs de reproducción multimedia. Esto se debe a que Fedora pretende ofrecernos alternativas libres frente al código y contenidos propietarios para hacer que sea completamente libre y redistribuible.
su -c 'yum localinstall --nogpgcheck http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm http://download1.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-stable.noarch.rpm'
Para terminar, debemos actualizar nuestros repositorios:
sudo yum check-update
Actualizamos:
sudo yum update
Ahora si ya estamos listos para poder instalar drivers y codecs privativos en nuestro equipo.

4. Mejorar yum

yum es como el apt-get de Ubuntu. Instalando unos pocos paquetes vamos a mejorarlo y hacer que funcione más rápido.
sudo yum -y install yum-plugin-fastestmirror
sudo yum -y install yum-presto
sudo yum -y install yum-langpacks
Reiniciá tu compu.

5. Configurar Gnome Shell

Esto puede ser de lo primero que desees hacer en Fedora, ya que viene el Shell de Gnome 3. Para configurarlo lo mejor será instalar gnome-tweak-tool para modificar el tema, las fuentes, etc. Dconf-editor te va a permitir modificar y personalizar aún más Fedora.
sudo yum install gnome-tweak-tool
sudo yum install dconf-editor

6. Instalar códecs de audio y video

sudo yum -y install gstreamer-plugins-bad gstreamer-plugins-bad-nonfree gstreamer-plugins-ugly gstreamer-ffmpeg
sudo yum -y install kernel-headers
sudo yum -y install kernel-devel
sudo yum -y install kernel-PAE-devel (Sólo Si tenes un Kernel PAE) OJO
sudo yum -y groupinstall "Development Tools"
sudo yum -y groupinstall "Development Libraries"
sudo yum -y install gstreamer-plugins-bad gstreamer-plugins-bad-free-extras gstreamer-plugins-bad-nonfree gstreamer-plugins-ugly gstreamer-ffmpeg



sudo yum -y install gstreamer1-libav gstreamer1-plugins-bad-free-extras gstreamer1-plugins-bad-freeworld gstreamer1-plugins-base-tools updates gstreamer1-plugins-good-extras gstreamer1-plugins-ugly gstreamer1-plugins-bad-free gstreamer1-plugins-good gstreamer1-plugins-base gstreamer1 

7. Instalar códecs para ver DVDs

sudo rpm -Uvh http://rpm.livna.org/livna-release.rpm
sudo yum check-update
sudo yum install libdvdread libdvdnav lsdvd libdvdcss

8. Instalar Flash

Flash 32/64 bits:
sudo yum install alsa-plugins-pulseaudio flash-plugin

9. Instalar java + plugin java

OpenJDK, la versión abierta de Java que es suficiente para la mayoría de las tareas.
sudo yum -y install java-1.7.0-openjdk
sudo yum -y install java-1.7.0-openjdk-plugin
Sin embargo, si sos desarrollador Java quizás te convenga instalar la versión oficial de Sun Java.
32bits:
sudo wget -c -O jre-oraclejava.rpm http://javadl.sun.com/webapps/download/AutoDL?BundleId=81809
sudo yum -y install jre-oraclejava.rpm
cd /usr/lib/mozilla/plugins/
sudo ln -s /usr/java/latest/lib/i386/libnpjp2.so
sudo echo 'PATH=/usr/java/latest/bin:$PATH' >> /etc/profile.d/java.sh
64bits:
sudo wget -c -O jre-oraclejava.rpm http://javadl.sun.com/webapps/download/AutoDL?BundleId=81811
sudo yum -y install jre-oraclejava.rpm
cd /usr/lib64/mozilla/plugins/
sudo ln -s /usr/java/latest/lib/amd64/libnpjp2.so
sudo echo 'PATH=/usr/java/latest/bin:$PATH' >> /etc/profile.d/java.sh

10. Instalar zip, rar, etc.

sudo yum -y install unrar p7zip p7zip-plugins

11. Instalar LibreOffice en español

sudo yum -y install libreoffice-base libreoffice-calc libreoffice-core libreoffice-draw libreoffice-impress libreoffice-langpack-es libreoffice-math libreoffice-writer hunspell hunspell-es

12. Instalar Wine

sudo yum install wine
sudo yum -y install cabextract

13. Instalar ffmpeg

sudo yum -y install ffmpeg

14. Instalar Mencoder

sudo yum -y install mencoder

15. Instalar ffmpeg2 theora

sudo yum -y install ffmpeg2theora

16. Instalar Mplayer

sudo yum -y install mplayer

17. Instalar Adobe

Adobe 32-bit x86
sudo yum -y localinstall http://linuxdownload.adobe.com/adobe-release/adobe-release-i386-1.0-1.noarch.rpm
Instalamos Flash
yum -y install flash-plugin
Adobe 64-bit x86_64
sudo yum -y localinstall http://linuxdownload.adobe.com/adobe-release/adobe-release-x86_64-1.0-1.noarch.rpm
Instalamos Flash
sudo yum -y install flash-plugin

18. Instalar converseen

sudo yum -y install converseen

19. Instalar PDFMod

PDFMod es una sencilla aplicación para la modificación de documentos PDF
sudo yum -y install pdfmod

20. Instalar VLC

sudo rpm -ivh http://download1.rpmfusion.org/free/fedora/rpmfusion-free-release-stable.noarch.rpm sudo yum install vlc
sudo yum -y update
sudo yum install mozilla-vlc (optional)

21. Instalar yumex

sudo yum -y install yumex

22. Instalar google-chrome

Primero habilitar el repositorio oficial de google chrome
Agregar un archivo de texto en la ruta /etc/yum.repos.d/google-chrome.repo con el siguiente contenido, de acuerdo a la arquitectura que uses de tu sistema operativo:
Con la siguiente línea se crea el archivo.
sudo /etc/yum.repos.d/google-chrome.repo
 Con línea siguiente se abre el archivo el editor gedit, copias el contenido de acuerdo a la arquitectura de tu sistema operativo y lo pegas dentro del archivo, lo guardas, actualizas y listo.
sudo gedit /etc/yum.repos.d/google-chrome.repo

64-bit
[google-chrome]
name=google-chrome - 64-bit
baseurl=http://dl.google.com/linux/chrome/rpm/stable/x86_64
enabled=1
gpgcheck=1
gpgkey=https://dl-ssl.google.com/linux/linux_signing_key.pub









32-bit
[google-chrome]
name=google-chrome - 32-bit
baseurl=http://dl.google.com/linux/chrome/rpm/stable/i386
enabled=1
gpgcheck=1
gpgkey=https://dl-ssl.google.com/linux/linux_signing_key.pub

Instalación de google-chrome en su versión estable
sudo yum install google-chrome-stable

23. Instalar VirtualBox

su -
su -c 'yum install -y kernel-headers kernel-devel dkms gcc'
sudo yum -y update 
sudo wget http://download.virtualbox.org/virtualbox/rpm/fedora/virtualbox.repo -O /etc/yum.repos.d/virtualbox.repo
sudo yum -y install VirtualBox-4.3
su -c '/etc/init.d/vboxdrv setup'
su -c 'usermod -G vboxusers -a username' (Reemplazando username por nuestro nombre de usuario)
 Y con ésto tendremos a Virtualbox instalado en la PC. Ahora tenemos que descargar el"Extension Pack" para asegurar mejor funcionamiento y compatibilidad de las máquinas virtuales, (controladores de mejor calidad y otras cosas)

24. Instalar nemo

sudo yum -y install nemo

25. Instalar unetbootin

sudo yum -y install unetbootin
 su -c 'yum install livecd-tools'
su -c 'yum install liveusb-creator' 

26. Instalar gparted

sudo yum -y install gparted

27. Instalar geany

sudo yum -y install geany

28. Instalar glade

sudo yum -y install glade

29. Instalar openshot

sudo yum -y install openshot

30. Instalar texlive (latex)

sudo yum -y install texlive-collection-latex texlive-collection-latexextra texlive-collection-science texlive-collection-latexrecommended texlive-collection-genericextra texlive-collection-genericrecommended texlive-collection-fontsrecommended tex-pst-optexp texlive-epstopdf-bin
sudo yum -y install texmaker
sudo yum -y install kile
sudo yum -y install gumi
 El comando anterior instalará todas las dependencias que se necesite para latex. También se incluyen alguno editores de código latex.

31. Instalar compresor lzma

sudo yum -y install xz

32. Instalar ncurses

su -c yum -y install ncurses-devel

33. Instalar gtk+

yum install gtk3-devel gtk2-devel

34. Instalar transmission

sudo yum -y install transmission

35. Instalar transmission

sudo yum -y install fritzing

36. Instalar arduino

sudo yum -y install arduino

37. Instalar umbrello

sudo yum -y install umbrello

38. Instalar wxmaxima

sudo yum -y install wxmaxima

39. Instalar tipografías de windows en fedora, más compatibilidad

En este How To veremos como poder instalar las fuentes tipográficas: ArialComic SansNew Times Roman, entre otras, de manera fácil, sencilla y gracias al siguiente script. Comencemos :).
Descargamos el script desde la pagina del autor:
wget "http://blog.andreas-haerter.com/_export/code/2011/07/01/install-msttcorefonts-fedora.sh?codeblock=1" -O "/tmp/install-msttcorefonts-fedora.sh"
Le damos permisos de ejecución:
chmod a+rx "/tmp/install-msttcorefonts-fedora.sh"
Ejecutamos el script:
su -c "/tmp/install-msttcorefonts-fedora.sh"
Al finalizar la instalación les pedirá reiniciar su equipo, les comento para evitar desastres.

40. Instalar vym

sudo yum -y install vym

41. Instalar scratch

sudo yum -y install scratch

42. Instalar foremost

sudo yum -y install foremost

Y ahora os presento una lista de reproductores de video en linux:
  • VLC: Reproductor multimedia completo y multisistema.
  • xine: Programa multimedia muy completo, especializado en reproducción de vídeo.
  • Totem: El reproductor oficial de películas para GNOME.
  • MPlayer: un motor muy potente y su front-end.
  • SMPlayer: front-end del MPlayer basado en Qt.
  • KMPlayer reproductor básico de audio/vídeo para KDE.
  • Kaffeine: el reproductor completo para KDE.
  • Ogle: reproductor DVD que soporta los menús de los DVD.
  • Helix: reproductor multimedia basado en el cliente Helix DNA.
  • Realplayer: reproductor de formatos de realaudio.
  • Miro: plataforma para televisión y vídeo para Internet.
  • Moovida Media Center: plataforma para televisión y vídeo para Internet.
  • Gnash: Reproductor de películas Flash.
Esta información fue recopilada de diferentes blogs.

Recibir datos desde arduino utilizando una interfaz en java

Ejecutar jbuttons desde arduino al presionar botones físicos.

Recientemente desarrollé una aplicación utilizando arduino para manipular una interfaz gráfica a través de botones físicos conectados a arduino. La interfaz gráfica fue hecha en java, utilizando netbeans 8.0 en fedora 20.

Fue la primera vez que utilicé arduino, además también fue la primera vez que conecté arduino con java.
Cuando se usa linux, por lo general se complica lo suficiente al querer ejecutar un programa, la mayoría de las veces es por cuestiones de permisos de archivos o permisos de ejecución de archivos, así también como los permisos que tenga el directorio donde está almacenado dicho ejecutable.

Antes de comenzar es necesario que tengan instalado:

  • Java
  • Arduino
  • Librerias de arduino
  • Netbeans 7.4 O superior


  • Tomaré en cuenta que ya tienen instalado los paquetes necesarios y continuaré con la explicación de la pequeña aplicación que he creado.
    Se utilizó la tarjeta arduino uno. 

    Descripción del proyecto: crear una interfaz en java utilizando jframe con 4 botones, cada botón realizará un determinada acción. Realizar un pequeño tablero con 4 pushbuttons conectados a arduino. La idea es que cuando se presione un botón en el tablero se ejecute la acción de un botón en la interfaz desarrollada en java. De tal modo que el dispositivo de interacción sea el tablero con botones.

    Realización:
    Primero se creará la interfaz gráfica, lo dejaré a su criterio, es un jframe que debe de tener 4 botones.

    Pueden crear una interfaz parecida a la imagen de arriba o hacer una que les convenga.
    Los botones físicos que estarán conectados a arduino pueden diseñarlos o colocarlos en un protoboard.
    El circuito es el siguiente:


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

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

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

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

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

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

    }

    El código de arduino parece mucho, pero las impresiones son más bien para saber qué está pasando en cada momento, así que descuiden, dependiendo de la necesidad que tengan, así pueden ir modificando dicho código.

    Después de que su código ya esté codificado en la tarjeta, procedemos a crear la aplicación en java.

    La clase principal, que se mostró en la primera imagen lleva el siguiente código. En realidad pueden crear sólo un jframe con 4 botones o los que consideren necesarios y listo.

    /*
     * La clase VentanaJuego que extiende jframe, contiene el juego principal,
        es decir, ésta clase es donde se muesra en sí todo el proceso del juego.
     */

    package ventanasScoop;

    import java.util.logging.Level;
    import java.util.logging.Logger;

    /**
     *
     * @author neo Jesús Fernando Merino Merino
     */
    public class VentanaJuego extends javax.swing.JFrame implements  Runnable{

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

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

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

        @Override
        public void run() {
            //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
            /*método que ejecuta acciones en la ventana de menú del jugador, de acuerdo
            a los datos que se reciben de los botones que se presionan desde el tapete*/
            String [] datosArd;
            while (permitBotArdVentJueg) {            
                datosArd = lectArdReciv.getDatRecArduino();
                //System.out.println("Datos de arduino: "+datosArd[0]+"  "+datosArd[1]+"  "+datosArd[2]+"  "+datosArd[3]);
                System.out.println("Datos de arduino: "+datosArd[0]);
                /*proceso de validar qué número de botón se ha presionado*/
                switch(datosArd[0]){
                    case "1":
                        jbIniciar.doClick();
                        break;
                    case "2":
                        jbRanking.doClick();
                        break;
                    case "3":
                        jbAyuda.doClick();
                        break;
                    case "4":
                        jbSalir.doClick();
                        break;
                    default:
                        break;
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException ex) {
                    Logger.getLogger(VentanaJuego.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }


    }

    Básicamente las funciones que están de azul, son las más importantes.
    En primera se inicia un un hilo que crea un objeto de tipo zyncronized, el cual lee constantemente desde el puerto que esté conectado arduino, luego valida qué botón fue el que se pulsó, de acuerdo al número que se recibe de arduino.
    Y lo que se hace es, que se ejecuta el doclic() del botón que se necesario. Y listo.
    La clase de arduino es la siguiente:
    package ventanasScoop;

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

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

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

        private void RecibirDatos() throws IOException {
            int Output1;
            Output1 = Integer.parseInt(Input.readLine());
            cont= Integer.parseInt(Input.readLine());
            System.out.println("Ouput1: "+Output1 +" valor recibido: "+cont);
        }

    }

    Ojo, necesitarán la librería librxtxSerial.so, también el jar RXTXcomm.jar, y lo colocan en la carpeta lib de su proyecto, y pues claro importan los jar para que funcione.
    Además en la pestaña propiedades de su proyecto deben especificar la ruta en donde se encuentra la librería librxtxSerial.so en la sección run en la descripción VM options: de preferencia muevan la librería librxtxSerial.so a la carptea lib de su proyecto, y coloquen la siguiente ruta.

    -Djava.library.path="../scoopControlButtons/lib/"


    Ejecutan su proyecto y deberá funcionar, en caso de que no, por favor envíenme un msj para aclarar dudas.