Java - capturar peso de una balanza electrónica, en código java ¡AYUDAA!

 
Vista:
sin imagen de perfil

capturar peso de una balanza electrónica, en código java ¡AYUDAA!

Publicado por anonymous (3 intervenciones) el 27/02/2017 04:18:14
Estoy haciendo un programa en java neatbeans. necesito capturar el valor de una balanza electrónica para hacer unos cálculos. ya sea que lo capture en un jText o algo...
alguien sabría el código en java para hacer esto. espero me ayuden :D
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
sin imagen de perfil
Val: 8
Ha aumentado su posición en 529 puestos en Java (en relación al último mes)
Gráfica de Java

capturar peso de una balanza electrónica, en código java ¡AYUDAA!

Publicado por Raymond (3 intervenciones) el 12/02/2020 04:33:25
buenas noches colegas programadores, les cuento que tube el mismo problema y despues de mucho codificar encontre la solucion.
les voy a dejar dos clases que se comportan excelentemente bn espero les guste.

primera clase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
import Archivos.Ventana;
import Formulario.FrameVentaPesado;
import Formulario.IngresoSistema;
import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.TooManyListenersException;
import java.util.logging.Level;
import java.util.logging.Logger;
 
public class LecturaSerial  {
	  //inicializamos y decalramos variables
	static CommPortIdentifier portId;
	static Enumeration puertos;
	static SerialPort serialport;
	static InputStream entrada = null;
	public static Thread t;
	//creamos un constructor para realizar la conexion del puerto
 
        public static boolean hayBalanza=false;
 
  	public LecturaSerial() {
            super();
            lecturaAnterior();
        }
 
        public static void lecturaAnterior(){
            puertos=CommPortIdentifier.getPortIdentifiers();
            t = new Thread(new LeerSerial());
            while (puertos.hasMoreElements()) { //para recorrer el numero de los puertos, y especificar con cual quiero trabajar
        	portId = (CommPortIdentifier) puertos.nextElement(); //next elemento recorre uno por uno
        	System.out.println("puerto "+portId.getName()); //puertos disponbibles
        	if (portId.getName().equals(IngresoSistema.puertoBalanza)) {
        		try {
                            serialport= (SerialPort)portId.open("LecturaSerial", 10);//tiempo ANTES ERA 9600
                            entrada = serialport.getInputStream();//esta variable del tipo InputStream obtiene el dato serial
                            t.start(); // inciamos el hilo para realizar nuestra accion de imprimir el dato serial
			} catch (Exception e) {
                        }
 
                }
            }
        }
 
        public static String salida="";
 
    //con este metodo del tipo thread relaizamos
  	public static class LeerSerial implements Runnable {
	   static int aux;
           public static boolean entrar=true;
 
           public void run () {
            while(entrar){
    		  try {
                        aux = entrada.read(); // aqui estamos obteniendo nuestro dato serial
                        esperar(1);//PAUSA PARA VERIFICAR
 			if (aux>0) {
                            salida=salida+String.valueOf((char)aux);
                            verifica2();
                           }
			} catch (Exception e) {}
                }
           }
 
           public void verifica(){
               if(contarPuntos()>2){
                   char []dat=quitarDatos(salida).toCharArray();
                   String bas="";
                   for(int i=buscaUltim();i<dat.length-1;i++)
                       bas=bas+String.valueOf(dat[i]);
                   if(bas.toCharArray().length>4){
                    FrameVentaPesado.cantidad.setText(bas);
                    FrameVentaPesado.pesando(quitarDatos(salida));
                    LecturaSerial.hayBalanza=true;
                   }
                   try {
                       Thread.sleep(4);
                   } catch (InterruptedException ex) {
                       Logger.getLogger(LecturaSerial.class.getName()).log(Level.SEVERE, null, ex);
                   }
               }
           }
 
           public static int control=0;
 
           public static void verifica2(){
                   char []dat=salida.toCharArray();
                   if(dat.length>8){
                        System.out.println("salida "+salida);
                        if(hola(salida)==true){
                            String dato=quitarDatos(salida);
                            FrameVentaPesado.cantidad.setText(dato);
                            System.out.println("salida sin puntos "+dato);
                            FrameVentaPesado.pesando(dato);
                            control=1;
                        }
                        LecturaSerial.hayBalanza=true;
                        //entrar=false;
                    if(dat.length>8){
                        salida="";
                    }
                   }
           }
 
           public static boolean hola(String cadena){
               char []vec=cadena.toCharArray();
               int con=0;
               for(int i=0;i<vec.length;i++){
                   if(vec[i]=='+'){
                       con=1;
                   }
                    if(vec[i]=='g')
                       con=2;
               }
               return con==2?true:false;
           }
 
           public static void esperar(int segundos) {
            try {
                //Thread.sleep (segundos*1000);
                Thread.sleep (segundos*10);
                } catch (Exception e) {}
            }
 
           public static String quitarDatos(String dato){
               if(dato==null) return "0";
               if(dato.equals("")) return "0";
               String salida="";
               char []vec=dato.toCharArray();
               for(int i=0;i<vec.length;i++){
                   if(vec[i]=='0' || vec[i]=='1' || vec[i]=='2' || vec[i]=='3' || vec[i]=='4' || vec[i]=='5' || vec[i]=='6' || vec[i]=='7' || vec[i]=='8' || vec[i]=='9' )
                       salida=salida+String.valueOf(vec[i]);
               }
               return salida;
           }
 
           public int contarPuntos(){
               char []dat=salida.toCharArray();
               int c=0;
               for(int i=0;i<dat.length;i++)
                   if(dat[i]=='.')
                       c++;
               if(c>3)
                   salida="";
               return c;
           }
 
           public int buscaUltim(){
               int c=0;
               char []dat=salida.toCharArray();
               for(int i=0;i<dat.length;i++)
                   if(dat[i]=='.')
                       c=i;
               return c-1;
           }
 
    }
 
}


segunda clase

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
import Formulario.FrameVentaPesado;
import Formulario.IngresoSistema;
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 java.io.*;
import java.util.*;
 
/**
 * Este es un ejemplo de uso del API de Comunicaciones Java que permite la
 * lectura de información a través de uno de los puertos serie de la
 * máquina en que se ejecuta.
 * El ejemplo se ha probado en Windows y Solaris, utilizando la línea
 * de código que identifica el puerto a utilizar correspondiente
 */
 
public class Comunication implements Runnable,SerialPortEventListener {
 
  static CommPortIdentifier idPuerto;
  static Enumeration listaPuertos;
  InputStream entrada;
  SerialPort puertoSerie;
  Thread tLectura;
 
  public static int ddd=0;
 
  // En este ejemplo implementa un thread que es el que se encarga de
  // que la aplicación se quede esperando en el puerto que se haya
  // abierto a que se reciban datos.
  // Primero abre el puerto y luego le fija los parámetros
  public Comunication() {
 
    // Si el puerto no está en uso, se intenta abrir
    try {
      puertoSerie = (SerialPort)idPuerto.open( "AplLectura",9600 );
    } catch( PortInUseException e ) {
    //System.out.println(e);
    }
    // Se obtiene un canal de entrada
    try {
      entrada = puertoSerie.getInputStream();
    } catch( IOException e ) {
    //System.out.println(e);
    }
 
    // Añadimos un receptor de eventos para estar informados de lo
    // que suceda en el puerto
    try {
      puertoSerie.addEventListener( this );
	  } catch( TooManyListenersException e ) {
          //System.out.println(e);
          }
 
    // Hacemos que se nos notifique cuando haya datos disponibles
    // para lectura en el buffer de la puerta
    puertoSerie.notifyOnDataAvailable( true );
 
    // Se fijan los parámetros de comunicación del puerto
    try {
      puertoSerie.setSerialPortParams( 9600,
        SerialPort.DATABITS_8,
        SerialPort.STOPBITS_1,
        SerialPort.PARITY_NONE );
    } catch( UnsupportedCommOperationException e ) {
        System.out.println(e);
    }
 
    // Se crea y lanza el thread que se va a encargar de quedarse
    // esperando en la puerta a que haya datos disponibles
    tLectura = new Thread( this );
    tLectura.start();
    }
 
    @Override
  public void run() {
    try {
      // En los threads, hay que procurar siempre que haya algún
      // método de escape, para que no se queden continuamente
      // bloqueados, en este caso, la comprobación de si hay datos
      // o no disponibles en el buffer de la puerta, se hace
      // intermitentemente
        //System.out.println("Entra hilo");
      Thread.sleep( 60000 );
    } catch( InterruptedException e )
    {
    //System.out.println(e);
    }
    }
 
 
    @Override
  public void serialEvent( SerialPortEvent _ev ) {
      //System.out.println("ENTRANDO");
    switch( _ev.getEventType() ) {
      // La mayoría de los eventos no se trata, éstos son los
      // que se producen por cambios en las líneas de control del
      // puerto que se está monitorizando
      case SerialPortEvent.BI:
      case SerialPortEvent.OE:
      case SerialPortEvent.FE:
      case SerialPortEvent.PE:
      case SerialPortEvent.CD:
      case SerialPortEvent.CTS:
      case SerialPortEvent.DSR:
      case SerialPortEvent.RI:
      case SerialPortEvent.OUTPUT_BUFFER_EMPTY:
        break;
      // Cuando haya datos disponibles se leen y luego se
      // imprime lo recibido en la consola
      case SerialPortEvent.DATA_AVAILABLE:
      byte[] bufferLectura = new byte[20];
      String salida="";
        try {
            int nBytes=0;
          while( entrada.available() > 0 ) {
            nBytes = entrada.read( bufferLectura );
            }
            System.out.println( new String(bufferLectura) );
            if(!IngresoSistema.quitarPuntos(quitaEspacios(new String(bufferLectura))).equals("")){
                FrameVentaPesado.cantidad.setText(IngresoSistema.quitarPuntos(quitaEspacios(new String(bufferLectura))));
                FrameVentaPesado.pesando(FrameVentaPesado.cantidad.getText());
            }
        } catch( IOException e ) {
            //System.out.println(e);
        }
        break;
      }
    }
 
    public String quitaEspacios(String cad){
      char []vec=cad.toCharArray();
      String salida="";
      for(int i=0;i<vec.length;i++)
          if(vec[i]=='0' || vec[i]=='1' || vec[i]=='2' || vec[i]=='3' || vec[i]=='4' || vec[i]=='5' || vec[i]=='6' || vec[i]=='7' || vec[i]=='8' || vec[i]=='9' || vec[i]=='.' ){
                salida=salida+String.valueOf(vec[i]);
                 }
      int cal=Integer.valueOf(salida);
      String salida2=String.valueOf(cal);
      Comunication.ddd=1;
      return salida2;
    }
 
    public static void comun(){
      // Lista de los puertos disponibles en la máquina. Se carga en el
    // mimo momento en que se inicia la JVM de Java
    listaPuertos = CommPortIdentifier.getPortIdentifiers();
 
    while( listaPuertos.hasMoreElements() ) {
      idPuerto = (CommPortIdentifier)listaPuertos.nextElement();
      if( idPuerto.getPortType() == CommPortIdentifier.PORT_SERIAL ) {
        if( idPuerto.getName().equals("COM3") ) {  //  Lector del puerto, se quedará esperando a que llegue algo al puerto
          Comunication lector = new Comunication();
          }
        }
      }
  }
 
}

hay les dejo para que se guien.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar