ackTap=2;
    			if (backupVector.size()>0)
    		{   
    			resendCounter = 0;
    			timeOutA();
    		}
    		}
    		else 
    		{
    			ackTap-=1;
    			startPop();  	
    		} 
  		  		   	    		    					    		    	
    	} 	
    	else
       	error("receive acitve event when node is already ACTIVE .....");       	    	
    }  	
    //*******************************
    //* when receving self pop event*
    //*******************************
    else if(msg==popEvent)
    {   
    	if(status==IS_ACTIVE)
    		startPop();
    	
    }
    else if(msg==timeOut)
    {
        if(status==IS_ACTIVE)
        	timeOutA();	
    }
    else if(msg==energe)
    	{ 
			if(x_energe.size()!=0)
			{ for(std::deque<std::string >::iterator iter = x_energe.begin();iter != x_energe.end();++iter)
			 {
			 		
			 		if(mysql_query(&mysql_mac,(*iter).c_str())!=0)
			 		{
			 			std::cout<<"execute insert syntax fail"<<
								std::endl<<mysql_error(&mysql_mac)<<endl;
						mysql_close(&mysql_mac);
						return;
			 		}
			 		
			 }
			
			 x_energe.clear();
			}
			 scheduleAt(simTime()+5.0, energe);
    		}
    		
    //**********************************
    //* when receving self sleep event *
    //**********************************
    else if (msg==sleepEvent)
    {        	
    	ev << logName() << "::AsyncMacLayer: node-" << findHost()->index() << " receiving--self-- " << msg << endl;   	    
        if(status==IS_ACTIVE)
        {
        	status=IS_SLEEP;
        	scheduleAt(simTime()+sleepTime,activeEvent);         	 			
	        if(popEvent->isScheduled())
	        {
	        	ev << logName() << "::AsyncMacLayer: cancel scheduled popEvent"<<endl;
	        	cancelEvent(popEvent);
	        }
	        if(timeOut->isScheduled())
	        {
	        	ev << logName() << "::AsyncMacLayer: cancel scheduled timeOut"<<endl;
	        	cancelEvent(timeOut);
	        }
	        // we begin to SLEEP. 
	        sleepTimestamp=simTime();	       
	                   
        }
        else
        	error("receive SLEEP event when node is already SLEEP .....");       
    }         
}




/**
 * Redefine this function if you want to process messages from upper
 * layers before they are send to lower layers.
 *
 * To forward the message to lower layers after processing it please
 * use @ref sendDown. It will take care of anything needed
 **/
void AsyncMacLayer::handleUpperMsg(MacPkt *mac)
{	 
	
	if (queue.length()<(int)par("frameCapacity"))
	{           
		ev<<logName()<<"::handleUpperMsg:: The ACKDestAddr is: "<<tempAddr<<endl;
       	        mac->setAckDestAddr(tempAddr);
       	
	   	queue.insert(mac);
	   	
	   	ev<<logName()<<"AsyncMacLayer::handleUpperMsg"<<" The queue length is(queue.length()) "<<queue.length()<<endl;
	   	
		
		if(findHost()->index()!=(int)findHost()->submodule("appl")->par("destAddress"))
    		
    	        ev<<logName()<<"AsyncMacLayer::handleUpperMsg"<<"The queue length is(backupVector.size())"<<backupVector.size()<<endl;
	}
	else
	{
		if(findHost()->index()!=(int)findHost()->submodule("appl")->par("destAddress"))
			//if number of the packets in queue go beyond the frameCapacity, set the node's color red 
    		findHost()->displayString().setTagArg("i",1, "red"); 
		ev << logName() << "::AsyncMacLayer: insert upper msg--to mac address "<<mac->getDestAddr()<<endl;
		delete mac;
	}
		
}




/**
 * Here is the place to implement a real medium access functionality.
 *
 * This basic implementation just forwards all message that ae
 * broadcast (destAddr = -1) or destined for this node (destAddr = nic
 * module id())
 *
 * Redefine this function if you want to process messages from lower
 * layers before they are forwarded to upper layers
 *
 * If you want to forward the message to upper layers please use
 * @ref sendUp which will take care of decapsulation and thelike
 **/
void AsyncMacLayer::handleLowerMsg(MacPkt *mac)
{	
		
		energyConsumption += rxEnergy*(mac->length())/(double)par("bitrate");  
  	if( mac->getDestAddr() == myMacAddr())//the packet is for me
  	{  	
    	sendUp(mac);
    	
    }
    
    else if((mac->getAckDestAddr()==myMacAddr()))// deal with ACK!!!!!!!!!!!
    {    	
        ev << logName() << "::AsyncMacLayer:: node-" << findHost()->index() << " currently queue length is:(backupVector.size()):: " << backupVector.size() << endl;
          		
  		  tempIterator = backupVector.begin();
        while( tempIterator != backupVector.end() ) {
    		if(mac->timestamp()==(*tempIterator)->timestamp())
    		{
    		//	delete *tempIterator;
    			backupVector.erase(tempIterator);          	
    			ev<<logName()<<"::handleLowerMsg:: The Pkt received is ACK from "<<getSenderName(mac)<<endl;
    			ev << logName() << "::AsyncMacLayer:: node-" << findHost()->index() << " currently queue length is:(backupVector.size()):: " << backupVector.size() << endl;
          if(mac->getDestAddr()==-1)
          {            		
              ev<<logName()<<"::handleLowerMsg:: The Pkt received is ACK from sink!!";
          }
          break;	    	    		
    		}
    		tempIterator++;
  		}       
       
        delete mac;    
    } 
  	else{
    	ev << logName() << "::AsyncMacLayer: message from "<<getSenderName(mac)<<" with mac addr "<<mac->getSrcAddr()<<" not for me (dest="<<mac->getDestAddr()<<") -> delete (my MAC="<<myMacAddr()<<")\n";    
    	delete mac;
  	}
}
        



void AsyncMacLayer::finish()
{
	BasicMacLayer::finish();	
	//CFile::Write(energyConsumption+'\n');
	FILE   *fp;   
  fp   =   fopen("c:\\asyncEnergy.txt","a");   
  fprintf(fp,   "%f\r\n",  energyConsumption);   
  fclose(fp);
  ev << logName() << "::AsyncMacLayer: Total energy consumed: " << energyConsumption <<"(mW)" <<endl;	
  //ev<<logName()<<"::AsyncMacLayer:have "<<tempCount.size()<<" adjust nodes"<<endl;
}




/**
 *  
 * resend the buffered msg in vector at the next wakeup time...
 * 
 **/
void AsyncMacLayer::timeOutA()
{ 
	if(status==IS_ACTIVE)
    {  
    	ev<<logName()<<"::AsyncMacLayer:: Begin to retry sending the pkt/ACK(sink) "<<endl;
    
    	if (resendCounter<(backupVector.size()/2))//???為什么小于一半
    	{	
    		
    		tempIterator = backupVector.begin();
    		for(int i=0; i<resendCounter; i++ )
    		{
     			tempIterator++;
   			}
   			
			//我認為這里resendCounter應該為backupVector.size()
			ev<<logName()<<"In the backupVector,still have "<<resendCounter<<" Pkts are waiting for being resent"<<endl;
			
			int counter=(*tempIterator)->getRetryLimit();	
			ev<<logName()<<"::The Pkt's re-send-counter is "<<counter<<endl;		
    		if(counter<(int)par("retryLimit"))
    		{    			
    			MacPkt *msg=(MacPkt* )(*tempIterator)->dup();
    			ev<<logName()<<"Make a copy and begin to resending"<<endl;    			
    			(*tempIterator)->setRetryLimit(counter+1);
    			energyConsumption += txEnergy*(msg->length())/(double)par("bitrate");
    			scheduleAt(simTime()+msg->length()/(double)par("bitrate")+0.001, timeOut);
    			sendDown((MacPkt*)msg);
    			resendCounter+=1;
    		}
    		//達到重發次數上限    		else
    		{
    			backupVector.erase(tempIterator);
    			ev<<logName()<<"::AsyncMacLayer:: reach max rtLimit!!! pkt deleted "<<endl;	
    			scheduleAt(simTime(), timeOut);
    		}	   		    		
    		
		}
    	else 
    	{   	
			scheduleAt(simTime(), popEvent);				
   		}	
 	}	
}