Lenguaje Java - Comunicaciones II

Comunicación Serial

Otro tipo de comunicación es la de tipo Serial, una de las más conocidos es la comunicación por cable RS-232, este tipo de conexión tiene un rango de transmisión de 10 metros como máximo, y pues solo hay 1 punto de inicio y 1 punto de destino, a diferencia del cable ethernet que al pasar por el router puede irse a donde sea, y que además aguanta una distancia de hasta 100 metros, pero la comunicación serial es la más usada para dispositivos electrónicos y pues es comunmente encontrada en programas industriales.

Hoy les mostraré como implemente uno de mis programas más usados para probar conexiones, se llama EasySend, el cual es un programa que lee los datos enviados por dispositivos de manera serial y los envia a un servidor ethernet como el que realizamos anteriormente para posteriormente pasarselos a un cliente que se conecte a este.

Construimos una clase Principal (JFrame):

Caja de texto COM-PUERTO = com

Caja de texto COM-Baudios= baud

Caja de texto Puerto servidor = puertos

Area de texto= consola

Antes de usar la librería para leer los puertos seriales, debemos importar su .jar muchas librerias que encontramos en internet se importan con sus .jar :

1) bajamos el archivo aqui

2) lo importamos

La librería que usaremos para leer puertos serial se llama SerialPort:

import app.Com;
import app.Parameters;
import core.SerialPort;

En total las librerías que usaremos son:

import java.util.List;  // para leer los puertos seriales disponibles
import app.Com;
import app.Parameters;
import core.SerialPort;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

Luego lo mismo de siempre, ponemos implementes Runnable para el thread de comunicación:

public class Principal extends javax.swing.JFrame implements Runnable

Los siguientes atributos

        public Com c2;
        public ServerSocket servidor;
        public Socket skCliente;
        public  OutputStream outstream;
        public DataOutputStream flujo;
        public Thread t;
        public Principal p;
        public String datos="";
        public String a;
        public String sensada="0.0";
        public int iden=3317;
        public boolean parte=false;

El método constructor:

public Principal() {
        initComponents();
        this.setVisible(true);
        try{

        SerialPort free = new SerialPort();
        List<String> portList = free.getFreeSerialPort();
            consola.setText("Puertos Libres");
        for (String string : portList) {
            consola.setText(consola.getText()+"\n"+string);
        }

      
        }catch(Exception g){
            g.printStackTrace();
        }
    }

La función parte, que se encargaba de identificar el "codigo y el valor", por ejemplo si recibí "1 123", el código es 1 y el valor es 123, esto se hace porque por el mismo puerto podemos recibir varios tipos de variables, por eso se necesitaba de un código para identificar cual era.

public static boolean parte(String s){
        try{
        int f=s.indexOf(" ");
        iden = Integer.parseInt(s.substring(0,f));
        sensada =s.substring(f+1);
        System.out.println("iden "+ iden);
        System.out.println("sensada " + sensada);
        parte = true;

        }catch(Exception j){
         parte =  false;
        }
        return parte;

   }

Ahora implementamos el método Run:

public void run(){
   
          System.out.println("ok");
            try {
                skCliente=servidor.accept();
                consola.setText(consola.getText()+"\n"+"Cliente :"+skCliente.getInetAddress());
                outstream = skCliente.getOutputStream();
                flujo= new DataOutputStream( outstream );
                while(true){

              

                 a= c2.receiveSingleString(); // método para leer un dato por Serial
                while(!a.equals("\n") ){
                a =c2.receiveSingleString();
                if(a.equals("\n") || a.equals(null) || a.equals("") ){
                   
                }else{
                 datos += a;
                }
               
                }
                 
                  System.out.println(" !"+datos+"! ");
                  parte(datos);
                 datos ="";
                 if(parte){
                   flujo.writeUTF(Integer.toString(iden) +" "+Double.parseDouble(sensada));
                   consola.setText(consola.getText()+"\n"+"Se envia : "+iden +" "+sensada);
                 }

              }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
 }

El evento de click del boton aceptar("boton"), para iniciar todo:

private void botonActionPerformed(java.awt.event.ActionEvent evt) {                                     
        try {
            Parameters settings = new Parameters();
            settings.setPort(com.getText());
            settings.setBaudRate(baud.getText());
            c2 = new Com(settings);
            consola.setText(consola.getText()+"\n"+"Se instala puerto :"+com.getText());
            servidor=new ServerSocket(Integer.parseInt(puertos.getText()));
            t=new Thread(p);
            t.start();
            // TODO add your handling code here:
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }    

El evento del boton enviar ("jButton1")

private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {                                     

        
            try{
                double d = Double.parseDouble("2.0");
                flujo.writeUTF("1" +" "+d);
                consola.setText(consola.getText()+"\n"+"Se envia : "+d);
            }catch(Exception sd){
                sd.printStackTrace();
            }


    }                      

Lenguaje Java - Comunicaciones I

Sockets

Bien, los denominados sockets son los que nos permiten enviar datos y recibir datos a travez de una conexión de red, es el denominado protocolo TCP/IP, generalmente cuando se trabaja con comunicaciones, se usan algoritmos dentro de un bucle infinito, por lo tanto necesitaríamos de los threads para poder implementar el algoritmo de comunicación.

Para programar en la comunicación Ethernet (TCP/IP) hay que entender el concepto de cliente y de servidor, el cliente es el que se conecta al servidor, es decir, para que halla comunicación el servidor se levanta primero y luego es capaz de aceptar 1 o más clientes a la vez según esté programado, a continuación les mostraré un simple ejemplo de un Messenger en Java usando la librería Sockets:

El cliente:

Creamos una clase Cliente de tipo JFrame, para poder hacer la ventana de Messenger:

Area de texto: area2

Caja de texto: area1

Ahora vamos a implementar la librería Sockets colocando:

import java.net.*;

También usaremos las siguientes librerías:

import java.io.*; // para poder usar los try catch

Seguido de esto vamos a hacer que la clase Cliente implemente el método run de Runnable para poder usar los threads:

Colocamos implements Runnable :

public class Cliente extends javax.swing.JFrame implements Runnable

Ahora declaramos los siguientes atributos que nos ayudarán en el funcionamiento del programa

  
    public  InputStream sIn; // para recibir datos
    public DataInputStream flujo; // para convertir datos recibidos
    public OutputStream salida; // para escribir datos ( enviar)
    public DataOutputStream flujo2; // para convertir los datos a enviar ( escribir )
    public Socket skCliente;  // el objeto socket que nos permite conectarnos
    public Thread j;  // el thread que usaremos en la comunicacion

Ahora el método constructor:

public Cliente() {
        initComponents();

        j=new Thread(this);
        try{
            j.start();
        }catch(Exception ds){
            System.out.println(ds.getMessage());
        }

}

implementamos el método run:

 public void run(){
   
         
           try{
           skCliente=new Socket("192.168.6.36",5000); // ip y puerto del servidor
           sIn=skCliente.getInputStream();
           salida=skCliente.getOutputStream();
           flujo2=new DataOutputStream(salida);
           flujo = new DataInputStream(sIn );
           area2.setText("Conectado a Servidor : "+skCliente.getInetAddress());
           int aux6;
           while( true ){
             aux6=flujo.read(); // se lee un byte como entero
               //el byte es convertido en caracter y luego se pone en la caja de texto "area2"
                area2.setText(area2.getText()+"\n"+(char)aux6);
      
              }else{
             
              }
           
           
             }

              }catch( Exception e ) {

              System.out.println( e.getMessage() );

               }
   
    }

Ahora programaremos el boton de click, para ello usaremos los denominados eventos, es decir el comportamiento de los componentes si sucede un "evento" como click, presionar tecla, recibir dato, cerrar componente, etc. En este caso usaremos el mouse clicked ( clic de mouse ).

 Luego implementamos el siguiente codigo dentro del evento, les debe quedar así:

 private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {                                     
        try {

            for(int i=0;i<area1.getText().length();i++){
                flujo2.write(area1.getText().charAt(i)); 

             // enviamos caracter por caracter de la palabra escrita en area1
            }
           
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    

    }   

Hasta aquí ya tenemos el cliente listo para conectarse al servidor, ahora vamos a programar la otra parte, el servidor:

Creamos una clase Servidor, igual que la anterior que sea JFrame:

Area de texto: area1

Caja de texto: texto

Al igual que el cliente, el servidor usará las mismas librerías:

import java.io.* ;
import java.net.* ;

Colocamos implements Runnable para usar los threads:

public class Servidor extends javax.swing.JFrame implements Runnable 

Usaremos los siguiéntes atributos:

 public   ServerSocket skServidor; // el servidor
 public   InputStream sIn;
 public  Thread ss; // el thread
 public  Socket skCliente;  // el cliente que acepta
 public  DataInputStream flujo2;
 public  InputStream instream;
 public DataOutputStream flujo;

public   String aux="";

public  OutputStream outstream;

El método constructor:

public Servidor() {
       
        initComponents();
        try {

        skServidor = new ServerSocket( 5000); // crea servidor con puerto 5000
        ss=new Thread(this);
       ss.start();
            } catch( Exception e ) {
                System.out.println( e.getMessage() );
            }
    
          
    }

El método run para la comunicación:

public void run(){
        
            try {
           
              skCliente=skServidor.accept();
              area1.setText("Cliente Aceptado: "+skCliente.getInetAddress());
              outstream = skCliente.getOutputStream();
              instream = skCliente.getInputStream();
              flujo2 = new DataInputStream(instream);
              flujo= new DataOutputStream( outstream );
             

              String aux="";
              int a;
             while( true ){
            
             a=flujo2.read();

             if(a==10){
              area1.setText("\n"+aux); // si recibe salto de linea pone el texto
             }
            
             if(a<15){
                
             }else{
               aux= aux+ (char)a;  // concatena los caracteres recibidos y al formar una palabra la pone
              
             }

             }
         
               }catch( Exception e ) {

              System.out.println( e.getMessage() );

               }

    }

El evento del boton enviar:

private void botonActionPerformed(java.awt.event.ActionEvent evt) {                                     

        String p;
        p=texto.getText()+"\n";
        try {

          for(int k=0;k<p.length();k++){
          flujo.write(p.charAt(k));
           }


        } catch (IOException ex) {
            ex.printStackTrace();
        }

}

Lenguaje Java - Threads

Hilos en Java (Threads)

Bueno, me tomé un tiempo para arreglar unos asuntos con mi carrera, pero ya estoy de regreso, el tema de hoy es un tema muy importante para la programación avanzada, en muchos casos nos es útil o necesario realizar procesos en parelelo, pero hasta ahora solo podíamos hacerlos consecutivamente 1 tras otro, pero los lenguajes de programación actuales tienen un sistema de "hilos" de procesos,  que manejan una serie distintas de procedimientos y se pueden ejecutar y detener según nuestras necesidades.

En java usaremos la clase Runnable

Al declarar una clase que va usar un hilo, tenemos que hacerla implementar ( sobreescribir el método run), para lograrlo, primero tenemos que poner import Runnable:

public class Test implements Runnable{

 public static void main(String args[]){

}

}

Una vez hecho esto ya tenemos que escribir el método run() en el cual tendremos que poner el código que queremos que se ejecute en paralelo.

public class Test implements Runnable{
 int i=0;
public Test(){
}

 public static void main(String args[]){
 
}

public void run(){

 i=i+1;

}

}

Para empezar a ejecutar el método run, debemos tener un objeto Thread ( hilo ), en este caso lo pondré como atributo, lo inicializaré en el main y le pondré a correr el método run.

public class Test implements Runnable{
 int i=0; // contador desde 0

Thread hilo; // el hilo

public Test(){
                               t.hilo=new Thread(this);  // se inicializa el hilo
                               hilo.start(); // se empieza el hilo ( llamamos al método run)

}

 public static void main(String args[]){
     Test t=new Test();            // llamamos al constructor                 
      
    while(true){  // este es el while-true normal, con el main

      System.out.println("_________________");
    }


}

public void run(){  // método run del hilo

 while(true){  // este es el while-true en paralelo , lo logramos en el método run del hilo



 i=i+1; // lo que hace este método es ir sumando la variable "i" e imprimiéndola infinitamente

System.out.println(i);


 }
}

}

Con el ejemplo anterior logramos hacer 2 bucles infinitos (while-true) en paralelo, lo cual nos es muy útil en determinadas situaciones, y por cada clase que creemos tedríamos otro proceso en paralelo para agregar, los threads o hilos se usan mucho en sistemas de comunicacion, dispositivos, actualizaciones rápidas, conteos, etc.

Lenguaje Java - JList y JComboBox

 Listas y ComboBox

Los componentes JList y JComboBox son muy importantes en sistemas de ventas, paneles de opciones, paneles de administracion de datos, es importante aprender a manejarlos tanto desde el diseño como en el código, generalmente estos componentes se manejan alimentándolos con datos de una base de datos o de manera manual, por ello veremos como hacerlo desde ambos lados.

Primero agregamos un JComboBox al JFrame:

Podemos llenar los "items", osea las palabras que están dentro de ese componente, en la propiedad model.

Desde código se hace de la siguiente manera:

String a[]=new String[] { "Item 1", "Item 2", "Item 3", "Item 4" };
jComboBox1.setModel(new javax.swing.DefaultComboBoxModel(a));

Selected Index nos dice la posición del elemento que está seleccionado en el componente, por ejemplo si queremos el primero pondremos 0, si ponemos el segundo será un 1.

La propiedad font le da las propiedades de formato a las palabras que van dentro del componente:

Bien ahora las propiedades del JList:
De la misma manera podemos editar los "items" en model:

En código se haría de la siguiente manera:

String[] a= { "Item 1", "Item 2", "Item 3", "Item 4", "Item 5" };
jList1.setModel(new javax.swing.AbstractListModel() {
            String[] strings = a;
            public int getSize() { return strings.length; }
            public Object getElementAt(int i) { return strings[i]; }
        });

Si queremos cambiar el color de fondo a la lista:

Bien uno de las cosas importantes cuando se programa con interfaz gráfica, es setear el Layout, esto quiere decir que define la manera de reaccionar al movimiento, clic, ingreso de datos (eventos), por ejemplo si agrandamos un componente puede que el Layout agrande también los demás o los cambie de posición, pues bien para que no pase esto personalmente uso Layout null :

Lenguaje Java - JLabel y JButton

Etiquetas y Botones

Siguiendo con el estudio de los componentes gráficos en Java, tenemos las etiquetas (labels), que generalmente se usan para poner un texto indicando algo o para poner una imagen en un frame.

Bien entonces, agregamos a nuestro proyecto un JLabel.

Le pueden poner el texto que quieran en la propiedad text, igual que el JTextBox....

Le pueden poner un cursor definido, en la propiedad cursor.....

Igualmente que el JTextArea y el JTextField, podemos ponerle borde....

Podemos ponerle formato a la letra que está dentro del label.

Bien, como les mencioné también podemos usar el JLabel para mostrar una imágen, en la propiedad icon.

Borramos el texto para que quede solo la imagen

Otro componente que generalmente se usa en Java, son los botones, JButton:

Tiene similares propiedades a los demás componentes, por ejempo el texto....

También tiene su propio cursor....

Le cambiaremos el nombre para poder editar algunas cosas desde código:

Si ponemos el nombre del botón en el código y luego ponemos el . (punto) saldrá un menú de propiedades del botón:

Cambiándole el texto al boton desde código.....

Lenguaje Java - JFrame

La Ventana - JFrame

Un frame, en netbeans es una clase también, es decir podemos crear un formulario JFrame llamado, Cliente, eso quiere decir que en esa ventana vamos a hacer todo lo referido al Cliente, si le ponemos de nombre por ejemplo Venta, en esa ventana pondremos una interfaz para vender productos, cobrar, etc.

Ahora veremos algunas de las propiedades más comunes de los JFrame, para ello creamos un proyecto con un JFrame:

Nos vamos a la pestaña source, que es la parte donde podemos editar parte del código:

 En la parte source, encontramos la clase (el frame), encontramos la definición del método constructor de esa clase y el main.

También encontramos que en el método costructor se llama al método initComponents

Ese método es automáticamente generado por NetBeans al momento de jalar un componente, elimianarlo o cambiarle alguna propiedad en la pestaña Diseño (Design):

Bien si queremos cambiarle por ejemplo que cuando le demos clic en el X roja de cerrar, no se cierre por ejemplo, lo podemos configurar en :

Si queremos que cuando el cursor parse por arriba de la ventana se ponga una manito, haremos lo siguiente:

También podemos editar las propiedades desde el código, de la siguiente manera:

Lenguaje Java - Interfaz Gráfica

GUI

(Graphic User Interface)

Bien, continuando con nuestro curso después de las recientes festividades les tengo un tema muy interesante, el cual es el manejo de las "ventanitas" como muchos les llaman, mejor dicho los JFrames, si ahora si vamos a hacer programas como los que suelen ver.

Bien lo primero que hacemos es abrir el netbeans y añadir un proyecto nuevo.

 

Le agregamos un formulario JFrame

 Le  ponemos un nombre cualquiera, en este caso Ventana

Y aquí tenemos nuestra primera ventana en Java, lista para editarse

Hay muchos componentes gráficos que java nos perrmite usar, los podemos ver en la parte derecha de la pantalla, en este caso jalaré un panel y lo pondré.

 Luego jalaré 2 paneles y les pondré color ( propiedades salen abajo de los componentes, tienen que darle clic al componente para cambiar sus propiedades), también agregaré 1 JLabel, para poner el texto.

Ejecutamos....

Aqui les presento algunos de los más comunes componentes (controles) usados en Java para programar las ventanas gráficas, la caja de texto, el panel, el boton, las etiquetas (labels), las listas , los checkbox, combobox, areas de texto, etc. incluso se pueden descargar componentes extras de internet que no vienen con el java original.

Aquí esta la parte de las propiedades que les mencioné, desde aquí pueden editar las propiedades del componente que hallamos seleccionado.

Bien espero que les halla gustado la introducción a la interfaz gráfica de Java espero que le den un buen uso y que sigan desarrollando sus aplicaciones, recuerden que el esfuerzo siempre va la pena.