serialportio.java

无线传感器网络操作系统源代码

            WriteSerialData ( data );
        }
    }

    private void ReadDummyData ()
    {
        SerialForward.DEBUG ( "SerialPortReader: sending dummy data" );

        while ( !m_bShutdown )
        {
            SerialForward.nBytesRead += SerialForward.PACKET_DUMMY_DATA.length;
            UpdatePacketForwarders ( SerialForward.PACKET_DUMMY_DATA );
            try { sleep ( dmmyDtPrd ); }
            catch (Exception e ) { }
        }
    }

    private void ReadDBData ( )
    {
	if ( m_dbReader == null ) {
	    m_bShutdown = true;
	    return;
	}
	java.sql.Timestamp lastTimestamp = null;
	java.sql.Timestamp crrntTimestamp = null;
	m_bShutdown = !(m_dbReader.Connect ());

	byte[] packet = m_dbReader.NextPacket();
	crrntTimestamp = m_dbReader.GetTimestamp ( );
	lastTimestamp = crrntTimestamp;
	while ( !m_bShutdown &&  packet != null ) {
	    if ( crrntTimestamp != null && lastTimestamp != null ) {
		
		//int crrntSec = lastTimestamp.getTime())*1000) + (int)(lastTimestamp.getNanos()/1000000);
		//int crrntMils = ((int)crrntTimestamp.getTime())*1000 + (int)(crrntTimestamp.getNanos()/1000000);
		int sleep = (int)(crrntTimestamp.getTime() - lastTimestamp.getTime());
		if ( sleep > 0 ) {
		    System.out.println ("Sleeping for: " + sleep );
		    try { sleep ( sleep ); }
		    catch (Exception e ) { } 
		}
	    } 
	    //try { sleep ( 500); }
	    //catch (Exception e ) {}
	    UpdatePacketForwarders ( packet );
	    System.out.println ( "Read packet from db ");
	    packet = m_dbReader.NextPacket();
	    lastTimestamp = crrntTimestamp;
	    crrntTimestamp = m_dbReader.GetTimestamp();
	}

	System.out.println ("Done reading packets from db");
    }

    private void ReadFileData ( )
    {
        /*ObjectInputStream ois = (ObjectInputStream) m_is;
        Object currentPckt;
        Object lastPckt = null;

        while ( !m_bShutdown )
        {
            try { currentPckt = ois.readObject(); }
            catch ( Exception e )
            {
                m_bShutdown = true;
                continue;
            }

            if ( currentPckt instanceof DataPckt )
            {
                SerialForward.settings.nBytesRead += ((DataPckt) currentPckt).data.length;
                if ( lastPckt == null )
                {
                  UpdatePacketForwarders ( ( (DataPckt) currentPckt).data );
                }
                else
                {
                  SimulatePcktDelay ( (DataPckt) currentPckt, (DataPckt) lastPckt );
                  UpdatePacketForwarders ( ( (DataPckt) currentPckt).data );
                }
                lastPckt = currentPckt;
            }
        }*/
    }
/*
    private void SimulatePcktDelay ( DataPckt currentPckt, DataPckt lastPckt )
    {
        long timeDelta = currentPckt.time.getTime() - lastPckt.time.getTime();
        if ( timeDelta < 0 ) { return; }
        else
        {
            try { this.sleep( timeDelta ); }
            catch ( InterruptedException e ) { }
        }
    }
*/
    public static void Shutdown ( )
    {
        if ( runningSerialPortIO != null )
        {
            runningSerialPortIO.Terminate();
        }
    }

    private void Terminate ( )
    {
        if ( !m_bTerminated ) {
            m_bTerminated = true;
            m_bShutdown = true;
            this.interrupt();
	    if ( m_dbReader != null ) {
		m_dbReader.Close ();
	    }
            if ( m_os != null ) {
                try { m_os.close(); }
                catch (IOException e ) { }
            }
            if ( m_is != null ) {
                try { m_is.close(); }
                catch ( IOException e ) { }
            }
            if ( serialPort != null )
            {
                serialPort.close();
            }

            runningSerialPortIO = null;
        }
    }
    private synchronized void RegisterPSForwarder ( ClientServicer cs )
    {
        m_vctPSForwarders.addElement ( cs );
        SerialForward.IncrementClients();
        SerialForward.DEBUG ( "SerialPortIO: Added listener to position: " + m_vctPSForwarders.size() );
    }



    private synchronized void UnregisterPSForwarder ( ClientServicer cs )
    {
        SerialForward.DEBUG ( "SerialPortIO: Removing packet stream forwarder" );
        UnregisterForwarder ( cs, m_vctPSForwarders );
    }

    private void UnregisterForwarder ( ClientServicer cs, Vector vct )
    {

        if ( !vct.removeElement( cs ) )
        {
          SerialForward.DEBUG ( "Unable to unregister listener");
          return;
        }
	// we always want to read from port even if we
	// have no clients...cause jason says so
	/*
        if ( m_vctPSForwarders.isEmpty() && !m_bSourceSim )
        {
            // no more forwarders, shutdown
            m_bShutdown = true;
	}*/

    }

    public void ReadSerialData()
    {
        int     serialByte;
        int     nPacketSize = SerialForward.PACKET_SIZE;
        int     count = 0;
        byte[]  packet = new byte[SerialForward.PACKET_SIZE];

        if ( m_is == null ) {
            // serial port must not have opened correctly
            m_bShutdown = true;
        }

        try
        {
            SerialForward.VERBOSE("SerialPortIO: Reading port");
            while (!m_bShutdown && (serialByte = m_is.read()) != -1 )
            //while ((serialByte = m_is.read()) != -1 )
            {
              packet[count] = (byte) serialByte;
              count++;
              SerialForward.nBytesRead++;
              if (count == nPacketSize)
              {
                count = 0;
                // send data to listener threads
                UpdatePacketForwarders ( packet );
                nPacketSize = SerialForward.PACKET_SIZE;
                packet = new byte[nPacketSize];
              }
              else if(count == 1 && serialByte != 0x7e)
              {
                  count = 0;
                  System.out.print (".");
              }
            }
        }
        catch ( IOException e )
        {
            m_bShutdown = true;
        }
    }

    public void WriteSerialData ( byte[] data )
    {
        try
        {
            if ( m_os != null ) { m_os.write( data ); }
        }
        catch ( IOException e )
        {
            SerialForward.VERBOSE( "Unable to write data to mote" );
        }
    }

    private synchronized void UpdatePacketForwarders ( byte[] packet )
    {
        SerialForward.IncrementPacketsRead ();
        ClientServicer currentCS;

        //SerialForward.VERBOSE( "Forwarding packets with contents: " + packet );
        for ( int i = 0; i < m_vctPSForwarders.size(); i++)
        {
            currentCS = (ClientServicer) m_vctPSForwarders.elementAt(i);
            try { currentCS.output.write( packet ); }
            catch ( IOException e )
            {
                currentCS.Shutdown ( );
                i--;
            }
        }
	/*
        if ( m_vctPSForwarders.size() == 0 )
        {
            m_bShutdown = true;
	    }*/
    }

    public void PrintAllPorts( )
    {
        Enumeration ports = CommPortIdentifier.getPortIdentifiers();

        if (ports == null) {
          SerialForward.VERBOSE("No comm ports found!" );
          return;
        }

        // print out all ports
        SerialForward.VERBOSE( "printing all ports..." );
        while ( ports.hasMoreElements() )
        {
          SerialForward.VERBOSE( "-  " + ((CommPortIdentifier)ports.nextElement()).getName() );
        }
    }


}