| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: GPSDriver.java 4914 2006-04-20 17:13:35Z jaume $

* $Log$

* Revision 1.12  2006-04-20 17:13:35  jaume

* *** empty log message ***

*

* Revision 1.11  2006/04/12 10:03:32  jaume

* *** empty log message ***

*

* Revision 1.10  2006/04/11 20:01:18  jaume

* *** empty log message ***

*

* Revision 1.9  2006/04/11 13:25:54  jaume

* *** empty log message ***

*

* Revision 1.8  2006/04/11 13:19:51  jaume

* *** empty log message ***

*

* Revision 1.7  2006/04/10 11:21:52  jaume

* *** empty log message ***

*

* Revision 1.6  2006/04/07 12:45:55  jaume

* *** empty log message ***

*

* Revision 1.5  2006/04/07 11:10:26  jaume

* *** empty log message ***

*

* Revision 1.4  2006/04/07 08:27:48  jaume

* *** empty log message ***

*

* Revision 1.3  2006/04/06 10:34:46  jaume

* *** empty log message ***

*

* Revision 1.1  2006/04/05 17:08:18  jaume

* *** empty log message ***

*

* Revision 1.2  2006/04/03 21:07:35  jaume

* *** empty log message ***

*

* Revision 1.1  2006/04/03 16:10:27  jaume

* *** empty log message ***

*

* Revision 1.1  2006/03/31 09:55:34  jaume

* *** empty log message ***

*

*

*/

package org.gvsig.gps;

import gnu.io.CommPortIdentifier;

import gnu.io.PortInUseException;

import gnu.io.SerialPort;

import gnu.io.UnsupportedCommOperationException;

import java.awt.geom.Point2D;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import org.gvsig.gps.exceptions.GPSReceiverException;

import org.gvsig.gps.listeners.GPSEventListener;

import org.gvsig.gps.parser.NMEA.GGASentence;

import org.gvsig.gps.parser.NMEA.GSASentence;

import org.gvsig.gps.parser.NMEA.IllegalSentenceException;

import org.gvsig.gps.parser.NMEA.NMEASentence;

import org.gvsig.gps.parser.NMEA.NMEASentenceFactory;

import org.gvsig.gps.parser.NMEA.RMCSentence;

import org.gvsig.gps.parser.NMEA.VTGSentence;

import com.iver.andami.PluginServices;

/**

 * <p>

 * Singleton class that handles the communication within the application and the

 * GPS receiver. It opens the port set with the setPort() method and establishes

 * the comunication via NMEA protocol.<br>

 * </p>

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 *

 */

public class GPSDriver extends Thread {

        private boolean connected = false;

        private ArrayList eventListeners = new ArrayList();

        // The timeOut field specifies how long a value received from the device

        // is valid. After this time, no more events of the corresponding class

        // will be fired.

        private static final long timeOut = 60 * 1000; // 60 seconds.

        private SerialPort serialPort = null;

        private InputStream inputStream;

        private OutputStream outputStream;

        private Hashtable register        = new Hashtable();

        private int rate = 1000;

        private long lastSampleTime;

        private boolean eventsEnabled;

        private double lonOffset = 0D;

        private double latOffset = 0D;

        private Point2D currentPos;

        private static GPSDriver instance = null;

        private static String fileName = "c:/gps points.txt";

        static BufferedWriter bw ;

        /**

         * Public instantiation of the driver is forbidden.

         */

        private GPSDriver() {};

        /**

         * <p>

         * This is a singleton object. Use this method to get the only one instance allowed.<br>

         * </p>

         * <p>

         * The use of the GPSDriver is very simple. Just set the port and the communciation

         * attributes through the setPort(...) method. Register a new listener into the driver

         * using the addEventListener(GPSEventListener) method. Then call start, stop as far

         * as it is a thread and your listeners will be notified about any event received

         * from the device.

         * </p>

         * @return

         */

        public static GPSDriver getInstance() {

                if (instance == null) 

                        instance = new GPSDriver();

                if (bw == null)

                        try {

                                bw = new BufferedWriter(new FileWriter(new File(fileName)));

                        } catch (IOException e) {

                                e.printStackTrace();

                        }

                return instance;

        }

        /**

         * Sets the port and its attributes used to comunicate to the receiver.

         * @param CommPortIdentifier portID, the port identifier

         * @param int portSpeed, the port speed expressed in bauds

         * @param int dataBits, value for the communication's data bits

         *                 (one of SerialPort.DATABITS_5, SerialPort.DATABITS_6, 

         *                                 SerialPort.DATABITS_7, or SerialPort.DATABITS_8)

         * @param int stopBits, value for the communication's stop bits

         *                 (one of SerialPort.STOPBITS_1, SerialPort.STOPBITS_1_5, or SerialPort.STOPBITS_2)

         * @param int parity, value for the communication's parity 

         *                 (one of SerialPort.PARITY_EVEN, SerialPort.PARITY_MARK,

         *                                 SerialPort.PARITY_NONE, SerialPort.PARITY_ODD, or

         *                          SerialPort.PARITY_SPACE). 

         * @throws PortInUseException

         */

        public void setPort(CommPortIdentifier portID, int portSpeed, int dataBits, int stopBits, int parity) throws PortInUseException{

                close();

                getInstance().serialPort = (SerialPort) portID.open("gvSIG", portSpeed);

                try {

                        getInstance().inputStream = getInstance().serialPort.getInputStream();

                        getInstance().outputStream = getInstance().serialPort.getOutputStream();

                        getInstance().serialPort.setSerialPortParams(

                                                                portSpeed, 

                                                                dataBits,

                                                                stopBits,

                                                                parity

                                                );

                } catch (UnsupportedCommOperationException e) {

                        e.printStackTrace();

                } catch (IOException e) {

                        e.printStackTrace();

                }

        }

        /**

         * Tells the driver to start monitoring and capturing data from the device.

         */

        public void connect() {

                getInstance().eventsEnabled = true;

                if (!getInstance().isAlive()) {

                        System.out.println("start");

                        getInstance().start();        

                }

        }

        public void run() {

                byte[] readBuffer = new byte[2048];

                StringBuffer line = new StringBuffer();

                try {

                        for (int bytes = getInstance().inputStream.read(readBuffer); bytes>-1; bytes = getInstance().inputStream.read(readBuffer)){

                                // Notify the listeners that the GPS is connected.

                                Iterator it = eventListeners.iterator();

                                while (!getInstance().connected && getInstance().eventsEnabled && it.hasNext()) {

                                        GPSEventListener l = (GPSEventListener) it.next();

                                        l.connectionEstablished();

                                }

                                getInstance().connected = true;

                                // Creates a new buffer to contain the previous readed bytes and the next bunch of bytes

                                String str = new String(readBuffer).substring(0, bytes);

                                int i = str.indexOf("\n");

                                if (i == -1) {

                                        line.append(str);

                                } else {

                                        line.append(str.substring(0,i));

                                        analyzeMessage(line.toString());

                                        line = new StringBuffer();

                                        line.append(str.substring(i+1,str.length()));

                                }

                        }

                        System.err.println("Sending request");

                        getInstance().outputStream.write(new String("$PMCAG,005,1,GGA,001").getBytes());

                        for (int bytes = getInstance().inputStream.read(readBuffer); bytes>-1; bytes = getInstance().inputStream.read(readBuffer)){

                                // Creates a new buffer to contain the previous readed bytes and the next bunch of bytes

                                String str = new String(readBuffer).substring(0, bytes);

                                int i = str.indexOf("\n");

                                if (i == -1) {

                                        line.append(str);

                                } else {

                                        line.append(str.substring(0,i));

                                        analyzeMessage(line.toString());

                                        line = new StringBuffer();

                                        line.append(str.substring(i+1,str.length()));

                                }

                                break;

                        }

                getInstance().inputStream = null;

                getInstance().outputStream = null;

                } catch (IOException e) {

                        e.printStackTrace();

                } catch (NullPointerException e) {

                }

                // Connection lost, will notify the listeners

                getInstance().connected = false;

                Iterator it = getInstance().eventListeners.iterator();

                while (getInstance().eventsEnabled && it.hasNext()) {

                        GPSEventListener l = (GPSEventListener) it.next();

                        l.connectionLost();

                }

        }

        /**

         * Parses the specific NMEA message.

         * @param line

         */

        private void analyzeMessage(String line) {

                try {

                        System.out.println("Analizing: "+line);

                        NMEASentence data = NMEASentenceFactory.createFromString(line);

                        NMEASentence oldData = (NMEASentence) getInstance().register.get(data.getName());

                        boolean mustNotifyListeners = !data.isEquivalentTo(oldData);

                        getInstance().register.put(data.getName(), data);

                        //if (mustNotifyListeners)

                                fireEvents();

                } catch (IllegalSentenceException e) {

                }

        }

        public static void sleep(long millis) {

                getInstance().sleep(millis);

        }

        public static void sleep(long millis, long nanos) {

                getInstance().sleep(millis, nanos);

        }

        /**

         * Sets the minimum interval between events in milliseconds.

         * @param millis

         */

        public void setSampleRate(int millis) {

                getInstance().rate = millis;

        }

        /**

         * Registers a new listener that will be notified about any event occured from

         * the gps receiver.

         * @param GPSEventListener l

         */

        public void addEventListener(GPSEventListener l) {

                getInstance().eventListeners.add(l);

        }

        /**

         * Iterates over the message registry and notifies the listeners

         */

        private void fireEvents() {

                Iterator it = getInstance().eventListeners.iterator();

                while (getInstance().eventsEnabled && it.hasNext()) {

                        GPSEventListener l = (GPSEventListener) it.next();

                        if (System.currentTimeMillis() - getInstance().lastSampleTime  >= getInstance().rate ) {

                                Iterator i = getInstance().register.keySet().iterator();

                                while (i.hasNext()) {

                                        NMEASentence aux = (NMEASentence) getInstance().register.get(i.next());

                                        if (isCurrent(aux)) {

                                                // This is a valid record

                                                if (aux instanceof GGASentence) {

                                                        GGASentence s = (GGASentence) aux;

                                                        {

                                                                try {

                                                                        bw.write(s.getLongitude() + "," + s.getLatitude()+"\n");

                                                                        bw.flush();

                                                                } catch (IOException e) {

                                                                        // TODO Auto-generated catch block

                                                                        e.printStackTrace();

                                                                }

                                                        }

                                                        getInstance().fireLonLatPositionReceived(l, s.getLongitude(), s.getLatitude());

                                                        l.precisionChanged(-1, s.getHDOP(), -1);

                                                        l.signalQualityChanged(0, s.getSatelliteCount(), s.getQualityStatus());

                                                        l.altitudeChanged(s.getAltitude());

                                                } else if (aux instanceof GSASentence) {

                                                        GSASentence s = (GSASentence) aux;

                                                        float[] dissolutions = s.getPrecisionDisolutions();

                                                        l.precisionChanged(dissolutions[0], dissolutions[1], dissolutions[2]);

                                                        s.getUsedSatellites();

                                                } else if (aux instanceof RMCSentence) {

                                                        l.unhandledMessage(aux.toString());

                                                } else if (aux instanceof VTGSentence) {

                                                        VTGSentence s = (VTGSentence) aux;

                                                        l.speedChanged(s.getSpeed(), s.getCourse());

                                                } else {

                                                        l.unhandledMessage(aux.toString());

                                                }

                                        } else {

                                                // This record is too old.

                                                getInstance().register.remove(aux);

                                        }

                                }

                                getInstance().lastSampleTime = System.currentTimeMillis();

                        }

                }

        }

        /**

         * Saves the position that is going to be delivered and notifies to the 

         * listener passed in the first agument that a new position has been received.

         * This is a convenience method and should not be called outside the fireEvents

         * method.

         * @param listener

         * @param longitude

         * @param latitude

         */

        private void fireLonLatPositionReceived(GPSEventListener listener, double longitude, double latitude) {

                getInstance().currentPos = new Point2D.Double(longitude, latitude);

                listener.newLonLatPositionReceived(longitude - lonOffset, latitude - latOffset);

        }

        /**

         * Tells if the sentence is considered as up-to-date.

         * @param NMEASentence

         * @return boolean

         */

        private boolean isCurrent(NMEASentence n) {

                return System.currentTimeMillis() - n.getTime() < timeOut;

        }

        /**

         * Silences the event firing. To resume the event firing just call <b>start()</b> method.  

         */

        public void silence() {

                getInstance().eventsEnabled = false;

        }

        /**

         * Closes the connection and frees any resource that the driver could be using.

         */

        public void close() {

                stop();

                if (getInstance().serialPort != null) {

                        getInstance().serialPort.notifyOnDataAvailable(false);

                        getInstance().serialPort.removeEventListener();

                        if (getInstance().inputStream != null) {

                                try {

                                        getInstance().inputStream.close();

                                }

                                catch (IOException e) {}

                        }

                        if (getInstance().outputStream != null) {

                                try {

                                        getInstance().outputStream.close();

                                        getInstance().outputStream = null;

                                }

                                catch (IOException e) {}

                        }

                        getInstance().serialPort.close();

                        getInstance().serialPort = null;

                }

                getInstance().connected = false;

                Iterator it = getInstance().eventListeners.iterator();

                while (getInstance().eventsEnabled && it.hasNext()) {

                        GPSEventListener l = (GPSEventListener) it.next();

                        l.connectionLost();

                }

                instance = null;

        }

        /**

         * Sets the offset of the GPS receiver. By default it is 0, but sometimes it

         * is useful to calibrate it.

         * 

         * @param lonOffset

         * @param latOffset

         * @throws GPSReceiverException 

         */

        public void setPosOffset(double lonOffset, double latOffset) {

                        this.lonOffset = lonOffset;

                        this.latOffset = latOffset;

        }

        /**

         * The very last position that the driver has delivered to the listeners. 

         * @return point2D

         */

        public Point2D getCurrentPosition() {

                return currentPos;

        }

        /**

         * Returns the current sample rate set.

         * @return

         */

        public int getSampleRate() {

                return rate;

        }

        public static void main(String[] args) {

                if (args.length < 4) {

                        System.out.print("GPSReader port portSpeed\n");

                        System.exit(-1);

                }

                Enumeration portList = CommPortIdentifier.getPortIdentifiers();

                while (portList.hasMoreElements()) {

                        CommPortIdentifier myPortId = (CommPortIdentifier) portList.nextElement();

                        if (myPortId.getPortType() == CommPortIdentifier.PORT_SERIAL) {

                                if (myPortId.getName().equals(args[0])) {

                                        try {

                                                GPSDriver driver = GPSDriver.getInstance();

                                                driver.setPort(myPortId, Integer.parseInt(args[1]), SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);

                                                driver.setSampleRate(100);

                                                driver.addEventListener(new GPSEventListener() {

                                                        public void unhandledMessage(String msg) {

                                                                System.out.println("UNHANDLED: "+msg);

                                                        }

                                                        public void connectionLost() {

                                                                System.out.println("CONNECTION LOST");        

                                                        }

                                                        public void connectionEstablished() {

                                                                System.out.println("CONNECTION ESTABLISHED");

                                                        }

                                                        public void newLonLatPositionReceived(double lon, double lat) {

                                                                System.out.println("NEW LONLAT POSITION RECEIVED: ("+lon+", "+lat+")");

                                                        }

                                                        public void signalQualityChanged(float level, int satellites, String qualityStatus) {

                                                                System.out.println("NEW SIGNAL LEVEL: "+level+" ("+satellites+" satellites in view)");

                                                        }

                                                        public void speedChanged(float speed, short course) {

                                                                System.out.println("SPEED/COURSE CHANGED: ( "+speed+" Km/h, "+course+" degrees)");

                                                        }

                                                        public void estimatedPosErrorChanged(double e) {

                                                                System.out.println("ESTIMATED POSITION ERROR CHANGED: "+e);

                                                        }

                                                        public void altitudeChanged(float height) {

                                                                System.out.println("HEIGHT CHANGED: "+height);

                                                        }

                                                        public void precisionChanged(float pDop, float hDop, float vDop) {

                                                                System.out.println("PRECISION CHANGED: "+pDop+", "+hDop+", "+vDop+")");

                                                        }

                                                });

                                                driver.connect();

                                        } catch (PortInUseException e) {

                                                System.err.println("Port busy");

                                        }

                                }

                        }

                }

        }

}