AVR Z-LINK®

SerialStream.java

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
package serialInterface;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.PrintStream;

import javax.comm.SerialPort;
import javax.comm.SerialPortEvent;
import javax.comm.SerialPortEventListener;
import javax.swing.event.EventListenerList;
public class SerialStream implements SerialPortEventListener{

        private SerialPort serialPort;
        private DataInputStream inputStream;
        private PrintStream outputStream;
        
        private boolean receptionDone;
        private boolean streamEventEnabled;
        private String  receivedOnStream;
        private EventListenerList SerialStreamListeners = new EventListenerList( );
        
        
        public SerialStream( SerialPort portToAppendStream ) throws SerialStreamException{
                
                //Open IO streams.
                try{
                        
                        inputStream = new DataInputStream( portToAppendStream.getInputStream( ) );
                        outputStream = new PrintStream( portToAppendStream.getOutputStream( ), true );
                }catch( IOException ioe ){

                        ioe.printStackTrace( );
                        
                        throw new SerialStreamException( "Not possible to open IO Streams." );
                }
                
                //Add this object instance as SerialPortEventListener.
                if( !SerialPortUtilities.addSerialEventListener( portToAppendStream, this) ){
                        throw new SerialStreamException( "Not possible to listen to chosen serial port." );
                }
                
                //Ready to receive new responses and disable serial stream event generation.
                receptionDone = false;
                streamEventEnabled = false;
        }
        
        public void sendData( String data ){
                
                receptionDone = false;
                outputStream.println( data );
        }
        
        public String getData( ){
                
                if( receptionDone ){
                        
                        return receivedOnStream;
                }
                
                //Reception is not finished.
                else{
                        return null;
                }
        }
        
        public String sendDataBlocking( String data ){
                
                this.sendData( data );
                
//              Wait until the response is termianted or an error occurs reading.
                while( !receptionDone );
                
                return receivedOnStream;
        }
        
        
        public SerialPort getSerialPortUsed( ){
                return serialPort;
        }
        
        
        public void enableSerialStreamEvents( ){
                streamEventEnabled = true;
        }
        
        
        public void disableSerialStreamEvents( ){
                streamEventEnabled = false;
        }
        
        
        public void resetReceiver( ){
                
                receptionDone = false;
        }
        
        public void serialEvent( SerialPortEvent spe ) {
                
                switch( spe.getEventType( ) ){
                
                //HW handshake not used.
            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;
            
            //Only react on new data available.
            case SerialPortEvent.DATA_AVAILABLE:
                
                StringBuffer readBuffer = new StringBuffer( );
                int c;
                    
                try{
                        
                        for( ; ( c = inputStream.read( ) ) != '\n'; ){
                                if( c!= '\r' )  readBuffer.append( ( char ) c);
                                }
                        
                        //Close stream.
                        inputStream.close( );
                        receptionDone = true;
                        }catch( IOException ie ){
                                
                                //Handle if we could not read from the serial port.
                                ie.printStackTrace( );
                                receptionDone = true;
                                receivedOnStream = "ERROR: Could not read from stream.";
                                
//                              Send a serial stream event to possible listeners if enabled.
                                if( streamEventEnabled ){
                                        
                                        fireSearialStreamEvent( new SerialStreamEvent( receivedOnStream ) );
                                }
                                
                                return;
                        }
                
                        //Add response to the receivedOnStream string.
                        receivedOnStream = readBuffer.toString( );
                        
                        //Send a serial stream event to possible listeners if enabled.
                        if( streamEventEnabled ){
                                fireSearialStreamEvent( new SerialStreamEvent( receivedOnStream ) );
                        }
         
                break;
                }
        }
        
        public void addSerialStreamEventListener( SerialStreamListener ssListener ){
                SerialStreamListeners.add( SerialStreamListener.class, ssListener );
        }
        
        public void removeSerialStreamListener( SerialStreamListener ssListener ){
                SerialStreamListeners.remove( SerialStreamListener.class, ssListener );
        }
        
        protected void fireSearialStreamEvent( SerialStreamEvent SerialStreamEvent ){
                
                Object[ ] listeners = SerialStreamListeners.getListenerList( );
                int numberOfListeners = listeners.length;
                
                for( int i = 0; i < numberOfListeners; i+=2 ){
                        
                        if( listeners[ i ] == SerialStreamListener.class ){
                                ( (SerialStreamListener)listeners[ i + 1 ] ).SerialStreamEvent( SerialStreamEvent );
                        }
                }
        }
}