acbasem.nc

主要用于无线传感网络的编写的书籍.对于初学者有着很大的用处

/* Anycast Base Implmentation. */
/* Modified by Kin Sun Ho (ksho@cse) */
/* Last Modified: 07 September 2005 */

/* Modified from TOSBase */
/*
 * @author Phil Buonadonna
 * @author Gilman Tolle
 */

/* leds 
   
   red: sending broadcast packets
   green: sending to UART
   yellow: receving data packets

*/


#ifndef TOSBASE_BLINK_ON_DROP
#define TOSBASE_BLINK_ON_DROP
#endif

module ACBaseM {
  provides interface StdControl;
  uses {
    interface StdControl as UARTControl;
    interface BareSendMsg as UARTSend;
    interface ReceiveMsg as UARTReceive;
    interface TokenReceiveMsg as UARTTokenReceive;
    
    interface StdControl as RadioControl;
    interface BareSendMsg as RadioSend;
    interface ReceiveMsg as RadioReceive;

    interface Leds;
    interface Timer as JTimer;
  }
}

implementation
{
  enum {
    UART_QUEUE_LEN = 12,
    RADIO_QUEUE_LEN = 12,
  };
  
  TOS_Msg    uartQueueBufs[UART_QUEUE_LEN];
  TOS_MsgPtr uartQueue[UART_QUEUE_LEN];
  uint8_t    uartIn, uartOut;
  bool       uartBusy, uartFull;
  
  TOS_Msg    radioQueueBufs[RADIO_QUEUE_LEN];
  TOS_MsgPtr radioQueue[RADIO_QUEUE_LEN];
  uint8_t    radioIn, radioOut;
  bool       radioBusy, radioFull;
  uint8_t    sequences;
  
  task void UARTSendTask();
  task void RadioSendTask();
  
  void failBlink();
  void dropBlink();
  
  command result_t StdControl.init() {
    result_t ok1, ok2, ok3;
    uint8_t i;
    
    sequences = 0;
    
    for (i = 0; i < UART_QUEUE_LEN; i++) {
      uartQueue[i] = &uartQueueBufs[i];
    }
    uartIn = uartOut = 0;
    uartBusy = FALSE;
    uartFull = FALSE;
    
    for (i = 0; i < RADIO_QUEUE_LEN; i++) {
      radioQueue[i] = &radioQueueBufs[i];
    }
    radioIn = radioOut = 0;
    radioBusy = FALSE;
    radioFull = FALSE;
    
    ok1 = call UARTControl.init();
    ok2 = call RadioControl.init();
    ok3 = call Leds.init();
    
    dbg(DBG_BOOT, "TOSBase initialized\n");
    
    return rcombine3(ok1, ok2, ok3);
  }
  
  command result_t StdControl.start() {
   
    call JTimer.start(TIMER_REPEAT,DISCOVERY);
    call UARTControl.start();
    call RadioControl.start();
    
    return SUCCESS;
  }
  
  command result_t StdControl.stop() {
    
    call UARTControl.stop();
    call RadioControl.stop();
    call JTimer.stop();
    
    return SUCCESS;
  }
  
  /*Broadcast Join packet*/
  task void BroadcastJoin() {
    struct Anycast *m;
    dbg(DBG_USR1, "Monitoring Node broadcasting Join packet.\n");    
    
    atomic { 
      m= (Anycast *) (radioQueue[radioOut])->data;
      m->type   = JOIN;
      m->src = TOS_LOCAL_ADDRESS;
      m->parent = TOS_LOCAL_ADDRESS;
      m->seqNum = sequences++;
      m->hop    = 0;
      
      radioQueue[radioOut]->group = TOS_AM_GROUP;
      radioQueue[radioOut]->addr = TOS_BCAST_ADDR;
      radioQueue[radioOut]->length = TOSH_DATA_LENGTH;
      
      if (!radioBusy) {
	call RadioSend.send(radioQueue[radioOut]);
	radioBusy = TRUE;
      } 
    }//end atomic   
  }//end Broadcast Join
  
  event TOS_MsgPtr RadioReceive.receive(TOS_MsgPtr Msg) {
    uint8_t t= Msg->data[0];//type of the packet
    TOS_MsgPtr pBuf = Msg;
    
    dbg(DBG_USR1, "TOSBase received radio packet.\n");
    
    if(Msg->addr != TOS_LOCAL_ADDRESS)
      return Msg;

    if(Msg->length != TOSH_DATA_LENGTH)
      return Msg;

    if ((!Msg->crc) || (Msg->group != TOS_AM_GROUP))
      return Msg;
    
    /*What Kind of message is it*/
    switch (t){
    case(DATA):
      call Leds.yellowToggle();
      atomic {
	if (!uartFull) {
	  pBuf = uartQueue[uartIn];
	  uartQueue[uartIn] = Msg;
	  
	  if( ++uartIn >= UART_QUEUE_LEN ) uartIn = 0;
	  
	  if (uartIn == uartOut) {
	    uartFull = TRUE;
	  }
	  
	  if (!uartBusy) {
	    if (post UARTSendTask()) {
	      uartBusy = TRUE;
	    }
	  }
	} else {
	  dropBlink();
	}
      }
      break;
    default:
      break;
    }
    
    return pBuf;
  }
  
  task void UARTSendTask() {
    bool noWork = FALSE;
    
    dbg (DBG_USR1, "TOSBase forwarding Radio packet to UART\n");
    
    atomic {
      if (uartIn == uartOut && uartFull == FALSE) {
	uartBusy = FALSE;
	noWork = TRUE;
      }
    }
    if (noWork) {
      return;
    }
    
    if(uartQueue[uartOut]->length != TOSH_DATA_LENGTH)
      return;

    if (call UARTSend.send(uartQueue[uartOut]) == SUCCESS) {
      call Leds.greenToggle();
    } else {
      failBlink();
      post UARTSendTask();
    }
  }
  
  event result_t UARTSend.sendDone(TOS_MsgPtr msg, result_t success) {
    
    if (!success) {
      failBlink();
    } else {
      
      atomic {
	if (msg == uartQueue[uartOut]) {
	  if( ++uartOut >= UART_QUEUE_LEN ) uartOut = 0;
	  if (uartFull) {
      	    uartFull = FALSE;
	  }
	}
      }
    }
    
    post UARTSendTask();

    return SUCCESS;
  }
  
  event TOS_MsgPtr UARTReceive.receive(TOS_MsgPtr Msg) {
    return Msg;
  }
  
  event TOS_MsgPtr UARTTokenReceive.receive(TOS_MsgPtr Msg, uint8_t Token) {
    TOS_MsgPtr  pBuf = Msg;
    bool reflectToken = FALSE;
    
    dbg(DBG_USR1, "TOSBase received UART token packet.\n");
    
    atomic {
      if (!radioFull) {
	reflectToken = TRUE;
	pBuf = radioQueue[radioIn];
	radioQueue[radioIn] = Msg;
	if( ++radioIn >= RADIO_QUEUE_LEN ) radioIn = 0;
	if (radioIn == radioOut)
	  radioFull = TRUE;
	
	if (!radioBusy) {
	  if (post RadioSendTask()) {
	    radioBusy = TRUE;
	  }
	}
      } else {
	dropBlink();
      }
    }

    if (reflectToken) {
      call UARTTokenReceive.ReflectToken(Token);
    }
    
    return pBuf;
  }

  task void RadioSendTask() {

    bool noWork = FALSE;

    dbg (DBG_USR1, "TOSBase forwarding UART packet to Radio\n");

    atomic {
      if (radioIn == radioOut && radioFull == FALSE) {
	radioBusy = FALSE;
	noWork = TRUE;
      }
    }
    if (noWork)
      return;

    radioQueue[radioOut]->group = TOS_AM_GROUP;
    
    if (call RadioSend.send(radioQueue[radioOut]) == SUCCESS) {
      call Leds.redToggle();
    } else {
      failBlink();
      post RadioSendTask();
    }
  }

  event result_t RadioSend.sendDone(TOS_MsgPtr msg, result_t success) {

    if (!success) {
      failBlink();
    } else {
      atomic {
	if (msg == radioQueue[radioOut]) {
	  if( ++radioOut >= RADIO_QUEUE_LEN ) radioOut = 0;
	  if (radioFull)
	    radioFull = FALSE;
	}
      }
    }
    
    post RadioSendTask();
    return SUCCESS;
  }

/* Time to rebrodcast Join Message*/
  event result_t JTimer.fired() {
    post BroadcastJoin();
    return SUCCESS;
  } 

  void dropBlink() {
#ifdef TOSBASE_BLINK_ON_DROP
    call Leds.yellowToggle();
#endif
  }

  void failBlink() {
#ifdef TOSBASE_BLINK_ON_FAIL
    call Leds.yellowToggle();
#endif
  }
}