Interfaz gráfica de usuario de Java que se conecta al puerto serie

Estoy creando una GUI de Java en Netbeans para que se ejecute en una computadora que se conectará al dispositivo a través de un puerto serie. Esta GUI es para mostrar la información del usuario que se almacenará en el otro dispositivo. Como un archivo de texto o para recuperar algunos datos de los sensores del dispositivo. Acabo de terminar el esquema de la interfaz y ahora es la parte más difícil, ya que es la primera vez que trato con puertos serie. El otro dispositivo es un beagleboard. No estoy seguro de por dónde empezar, ya que he buscado en este foro, pero nada parece relacionarse exactamente con mi pregunta. Supongo que debo establecer una conexión a través del puerto con el dispositivo y enviar las solicitudes de información que solicita el usuario.

¿Algún consejo? ¿Debería establecerse la conexión en una clase Java separada del programa? La interfaz gráfica está compuesta por un JFrame principal y dos auxiliares y yo (plan) tengo un botón para establecer la conexión en el marco principal básicamente.

Gracias de antemano, Alex

preguntado el 12 de junio de 12 a las 16:06

"La interfaz gráfica de usuario se compone de un JFrame principal y dos auxiliares" Vea El uso de múltiples JFrames, ¿buena o mala práctica? -

@Andrew Thompson: Alguien por ahí está enseñando activamente a las personas a usar múltiples JFrames. Me siento como un salmón, nadando contra la corriente, cuando te veo escribir o me escribo sobre un único JFrame. -

@GilbertLeBlanc "cuando te veo escribir" Oh, para mí es copiar/pegar de mis 'líneas más usadas'. No me molesté en escribirlo cada vez Lo uso. ;) -

@AndrewThompson: Gracias por el consejo, supongo que tendré que investigarlo. Realmente no parece fácil de usar solo para empezar. -

1 Respuestas

¿Debería establecerse la conexión en una clase Java separada del programa?

Si. Una clase de java debería ser suficiente para establecer la conexión, enviar mensajes al beagleboard y recibir respuestas.

Supongo que debo establecer una conexión a través del puerto con el dispositivo y enviar las solicitudes de información que solicita el usuario.

Si. Formatearía las solicitudes en cualquier formato que requiera el beagleboard.

Aquí hay una clase que armé para asegurarme de que se ejecutó una sola instancia de la aplicación Java. Usted modificaría esto para sus comunicaciones.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

public class ApplicationInstanceManager {

    private static final boolean DEBUG = false;

    private static ApplicationInstanceListener subListener;

    /** Randomly chosen, but static, high socket number */
    public static final int SINGLE_INSTANCE_NETWORK_SOCKET = 44331;

    /** Must end with newline */
    public static final String SINGLE_INSTANCE_SHARED_KEY = "$$RabidNewInstance$$\n";

    /**
     * Registers this instance of the application.
     * 
     * @return true if first instance, false if not.
     */
    public static boolean registerInstance() {
        // returnValueOnError should be true if lenient (allows app to run on
        // network error) or false if strict.
        boolean returnValueOnError = true;
        // try to open network socket
        // if success, listen to socket for new instance message, return true
        // if unable to open, connect to existing and send new instance message,
        // return false
        try {
            final ServerSocket socket = new ServerSocket(
                    SINGLE_INSTANCE_NETWORK_SOCKET, 10, InetAddress
                            .getLocalHost());
            if (DEBUG)
                System.out.println("Listening for application instances on socket "
                    + SINGLE_INSTANCE_NETWORK_SOCKET);
            Thread instanceListenerThread = new InstanceListenerThread(socket);
            instanceListenerThread.start();
            // listen
        } catch (UnknownHostException e) {
            EclipseLogging.logError(RabidPlugin.getDefault(),
                    RabidPlugin.PLUGIN_ID, e);
            return returnValueOnError;
        } catch (IOException e) {
            return portTaken(returnValueOnError, e);

        }
        return true;
    }

    private static boolean portTaken(boolean returnValueOnError, IOException e) {
        if (DEBUG)
            System.out.println("Port is already taken.  "
                    + "Notifying first instance.");
        try {
            Socket clientSocket = new Socket(InetAddress.getLocalHost(),
                    SINGLE_INSTANCE_NETWORK_SOCKET);
            OutputStream out = clientSocket.getOutputStream();
            out.write(SINGLE_INSTANCE_SHARED_KEY.getBytes());
            out.close();
            clientSocket.close();
            System.out.println("Successfully notified first instance.");
            return false;
        } catch (UnknownHostException e1) {
            EclipseLogging.logError(RabidPlugin.getDefault(),
                    RabidPlugin.PLUGIN_ID, e);
            return returnValueOnError;
        } catch (IOException e1) {
            EclipseLogging
                    .logError(
                            RabidPlugin.getDefault(),
                            RabidPlugin.PLUGIN_ID,
                            "Error connecting to local port for single instance notification",
                            e);
            return returnValueOnError;
        }
    }

    public static void setApplicationInstanceListener(
            ApplicationInstanceListener listener) {
        subListener = listener;
    }

    private static void fireNewInstance() {
        if (subListener != null) {
            subListener.newInstanceCreated();
        }
    }

    public static void main(String[] args) {
        if (!ApplicationInstanceManager.registerInstance()) {
            // instance already running.
            System.out.println("Another instance of this application " + 
                    "is already running.  Exiting.");
            System.exit(0);
        }
        ApplicationInstanceManager
                .setApplicationInstanceListener(new ApplicationInstanceListener() {
                    public void newInstanceCreated() {
                        System.out.println("New instance detected...");
                        // this is where your handler code goes...
                    }
                });
    }

    public static class InstanceListenerThread extends Thread {

        private ServerSocket socket;

        public InstanceListenerThread(ServerSocket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            boolean socketClosed = false;
            while (!socketClosed) {
                if (socket.isClosed()) {
                    socketClosed = true;
                } else {
                    try {
                        Socket client = socket.accept();
                        BufferedReader in = new BufferedReader(
                                new InputStreamReader(client.getInputStream()));
                        String message = in.readLine();
                        if (SINGLE_INSTANCE_SHARED_KEY.trim().equals(
                                message.trim())) {
                            if (DEBUG)
                                System.out.println("Shared key matched - "
                                        + "new application instance found");
                            fireNewInstance();
                        }
                        in.close();
                        client.close();
                    } catch (IOException e) {
                        socketClosed = true;
                    }
                }
            }
        }
    }
}

Respondido el 12 de junio de 12 a las 17:06

Gracias, tendré que investigar y ver si funciona usando sockets, en su mayoría había visto a personas que recomiendan el uso de javax.comm o el clon RXTX. Y parece que también tendré que investigar los múltiples JFrames... - alex91

Ahora que tuve tiempo de usar el código y comenzar a entender lo que juntas, tengo algunas preguntas adicionales. privado estático ApplicationInstanceListener subListener; ¿Esta sería otra clase en el proyecto que estaría esperando que se hiciera la instancia? y una cosa más: EclipseLogging, ¿de dónde viene eso? ¿Es algún tipo de archivo de registro para almacenar errores? Gracias de antemano, Alex- alex91

@alex91: EclipseLogging es parte de un complemento de Eclipse que escribí específicamente para mostrar y registrar los errores del complemento de Eclipse. ApplicationInstanceListener es un oyente que creé con un método, newInstanceCreated(). El código de escucha real que escribí es parte de una clase de aplicación de complemento de Eclipse diferente, para forzar el enfoque de la ventana actual de Eclipse. Su código de oyente obviamente sería diferente. - gilbert le blanc

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.