De regreso!

Hola queridos amigos!

Mis más sinceras disculpas, la verdad que hace cerca de un año que ya dejé de publicar por motivos de trabajo y de estudios, pero ya estoy de vuelta y con mayores conocimientos!

Estos días publicaré algunas nuevas entradas de programación, estén atentos!

PDTA: Les dejo mi nueva web!
http://www.buenosconsejos.dx.am

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.

Feliz Año Nuevo

Bien, paso para desearles un feliz año nuevo muchachos, le deseo de todo corazón que los éxitos les sigan llegando y que siempre den lo mejor de ustedes para seguir adelante.

Un agradecimiento en éste el primer mes de mi blog a todos los usuarios que leen mis lecciones, cada vez somos más lectores y más seguidores, recibí un correo de un amigo desde suiza saludos a toda la gente por ese lado del globo! y pues saludos a todos y que lo pasen de lo mejor hoy en la noche !!!

Saludos.
David

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.....