serialconnector.java

传感器网络中的嵌入式操作系统源代码

        java.util.HashSet listenerList;
        if(messageIdRegisterMap.containsKey(new Integer(messageID))) {
            listenerList = (java.util.HashSet) this.messageIdRegisterMap.get(new Integer(messageID));
        }else {
            listenerList = new java.util.HashSet();
            this.messageIdRegisterMap.put(new Integer(messageID),listenerList);
        }
        if(clientRegisterMap.containsKey(packetListener)){
            
            ClientThread clientHandler = (ClientThread)clientRegisterMap.get(packetListener);
            clientHandler.references++;
        }else{
            ClientThread newClientHandler = new ClientThread(packetListener);
            clientRegisterMap.put(packetListener,newClientHandler);
            newClientHandler.references++;
            newClientHandler.start();
        }
        
        listenerList.add(packetListener);
        
    }
    
    public boolean removePacketListener(PacketListenerIF packetListener, int messageID){
        java.util.HashSet listenerList;
        if(messageIdRegisterMap.containsKey(new Integer(messageID))) {
            listenerList = (java.util.HashSet) this.messageIdRegisterMap.get(new Integer(messageID));
        }else {
            return false;
        }
        if(clientRegisterMap.containsKey(packetListener)){
            ClientThread clientHandler = (ClientThread)clientRegisterMap.get(packetListener);
            if(--clientHandler.references==0){
                clientHandler.end();
                clientRegisterMap.remove(packetListener);
            }
        }
        
        if(listenerList.remove(packetListener)){
            if(listenerList.isEmpty())
                messageIdRegisterMap.remove(new Integer(messageID));
            return true;
        }
        return false;
    }

    public boolean removePacketListener(MessageCenterInternalFrame packetListener){
        java.util.HashSet listenerList;
        java.util.Iterator mapIt = messageIdRegisterMap.keySet().iterator();
        while(mapIt.hasNext()){
            Object key = mapIt.next();
            if(messageIdRegisterMap.containsKey(key)) {
                listenerList = (java.util.HashSet) this.messageIdRegisterMap.get(key);
            }else {
                continue;
            }
            if(clientRegisterMap.containsKey(packetListener)){
                ClientThread clientHandler = (ClientThread)clientRegisterMap.get(packetListener);
                if(--clientHandler.references==0){
                    clientHandler.end();
                    clientRegisterMap.remove(packetListener);
                }
            }

            if(listenerList.remove(packetListener)){
                if(listenerList.isEmpty())
                    messageIdRegisterMap.remove(key);
                
            }
            
        }
        return true;
    }

    
    
    public boolean sendMessage(int address, short type, short dgroup /*deprecated*/, byte[] data){
        if(data.length > Integer.parseInt(packetSizeTextField.getText()))
            return false;
        
        sentTextField.setText(Long.toString(++msgsent));
        TOSMsg tosPacket = new TOSMsg(this.getMsgLength());
        //address
        tosPacket.set_addr(address);
        //System.out.println("address "+messageAdress);
        //type
        tosPacket.set_type(type);
        //System.out.println("type "+pollActiveMessage);
        //Group
        tosPacket.set_group(this.group);
        //System.out.println("group "+groupId);
        //Length
        tosPacket.set_length((short)data.length);
        //System.out.println("length "+(short)data.length);
        //data
        tosPacket.dataSet(data, 0, tosPacket.offset_data(0), data.length);
        //CRC
        tosPacket.set_crc(1);
        
        
        try{
            if(serialStub != null){
                serialStub.writePacket(net.tinyos.packet.BrokenPacketizer.collapsePacket(tosPacket.dataGet()));
            }
            return true;
        }catch(java.io.IOException ioe){
            System.err.println(ioe);
        }
        return false;
        
    }
    
    /******************************Inner Classes***********************************/
    protected class DistributorThread extends Thread{
        
        byte[] packet;
        
        PacketListenerIF destination;
        boolean running = true;
        
        public void end(){
            running = false;
        }
        
        public void run(){
            
            while(running){
                if(!packetBuffer.isEmpty()){
                    distributeBuffer();
                }else{
                    try{
                        //System.out.println("Sleeping");
                        this.sleep(100);
                    }catch(InterruptedException ie ){                    }
                }
            }
        }
        
        private synchronized void distributeBuffer(){
            while(!packetBuffer.isEmpty()){
                //System.out.println("Buffer Size: " + packetBuffer.size());
                packet =(byte[])packetBuffer.get(0);
                packetBuffer.remove(0);
                
                java.util.HashSet toNotify = new java.util.HashSet();
                
                
                if(messageIdRegisterMap.containsKey(new Integer(GET_ALL_MESSAGES))) {
                    toNotify.addAll((java.util.HashSet)messageIdRegisterMap.get(new Integer(GET_ALL_MESSAGES)));
                }
                if(messageIdRegisterMap.containsKey(new Integer(packet[PACKET_TYPE_FIELD]))) {
                    toNotify.addAll((java.util.HashSet)messageIdRegisterMap.get(new Integer(packet[PACKET_TYPE_FIELD])));
                }
                
                java.util.Iterator notifyListIterator = toNotify.iterator();
                
                while(notifyListIterator.hasNext()){
                    
                    PacketListenerIF packetIF =(PacketListenerIF)notifyListIterator.next();
                    if(clientRegisterMap.containsKey(packetIF)){
                        ClientThread clientHandler = (ClientThread)clientRegisterMap.get(packetIF);
                        clientHandler.forwardPacketReceived(packet,packetIF);
                        msgadded++;
                    }
                }
            }
        }
        
    }
    
    protected class ClientThread extends Thread{
        
        //byte[] packet;
        private java.util.Vector messageBuffer;
        PacketListenerIF destination;
        boolean running = true;
        public int references = 0;
        
        /*public ClientThread(){
        }*/
        
        public ClientThread(PacketListenerIF destination){
            this.destination = destination;
            messageBuffer = new java.util.Vector();
        }

        public synchronized void  forwardPacketReceived(byte[] packet, PacketListenerIF destination) {
            messageBuffer.add(packet);
            //this.packet = packet;
            //this.destination = destination;

        }
        
        public void end(){
            running = false;
        }
        
        public void run(){
            while(running)
                if(!messageBuffer.isEmpty()){
                    sendBuffer();
                }else{
                    try{
                        this.sleep(100);
                    }catch(InterruptedException ie ){}
                }
        }
        
        private synchronized void sendBuffer(){
            while(!this.messageBuffer.isEmpty()){
                this.destination.packetReceived((byte[])this.messageBuffer.get(0));
                this.messageBuffer.remove(0);
                msgposted++;
                //System.out.println("recvd:"+msgreceived+" added:"+msgadded+"posted:"+msgposted);
            }
        }
        
    }
    
    protected class PacketReader extends Thread implements PacketListenerIF{
        boolean run = true;
        byte[] buffer = null;
        public void run(){
            try{
                while(run){
                    buffer = serialStub.readPacket();
                    packetReceived(buffer);
                }
            }catch(Exception e){
            }
        }
        
        public void stopRun(){
            run = false;
        }
        
        // the first 5 bytes are: addr(2), type(1), group(1), length(1)
        public void packetReceived(byte[] packet) {
            //packetBuffer.add(packet);
            receivedTextField.setText(Long.toString(++msgreceived));
            //System.out.println("Type: " +Integer.toHexString(0xFF & packet[2]));
            
            java.util.HashSet toNotify = new java.util.HashSet();
            
            if(messageIdRegisterMap.containsKey(new Integer(GET_ALL_MESSAGES))) {
                toNotify.addAll((java.util.HashSet)messageIdRegisterMap.get(new Integer(GET_ALL_MESSAGES)));
            }
            if(messageIdRegisterMap.containsKey(new Integer(packet[PACKET_TYPE_FIELD]))) {
                toNotify.addAll((java.util.HashSet)messageIdRegisterMap.get(new Integer(packet[PACKET_TYPE_FIELD])));
            }
            java.util.Iterator notifyListIterator = toNotify.iterator();
            while(notifyListIterator.hasNext()){
                ((PacketListenerIF)notifyListIterator.next()).packetReceived(packet);
                /*PacketListenerIF packetIF =(PacketListenerIF)notifyListIterator.next();
                if(clientRegisterMap.containsKey(packetIF)){
                    ClientThread clientHandler = (ClientThread)clientRegisterMap.get(packetIF);
                    clientHandler.forwardPacketReceived(packet,packetIF);
                    msgadded++;
                }*/
             
             
             
             
            }
            
        }
        
    }
    
}