acbasem.nc

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

/* Anycast/Marzullo 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

*/

includes Sasha;

#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;
    interface Timer as MTimer;
    interface Marzullolib;
    interface StdControl as MarzulloControl;
  }
}

implementation
{
  enum {
    UART_QUEUE_LEN = 12,
    RADIO_QUEUE_LEN = 12,
  };
 
  TOS_Msg    marzullo_result;
  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; // sequences number
  uint8_t    state;     // current state 
  uint8_t    repeat;    // number of repeat for request broadcast
  uint16_t   min;       //  - | used to do the verify
  uint16_t   max;       //  - |
  uint16_t   record[MAX_MOTES]; // resizeable array of Mote Info
  uint8_t    nrecord;   // number of mote heard
  uint8_t    fault_mote;// number of fault mote
  
  task void UARTSendTask();
  task void RadioSendTask();
  
  void failBlink();
  void dropBlink();
  
  command result_t StdControl.init() {
    result_t ok1, ok2, ok3;
    uint8_t i;

    atomic {
      sequences = 0;
      state = TRAINING;
      repeat = REPEAT_MSG;
    }

    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();
    call MTimer.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;
      
      if(state == TRAINING || state == VERIFY) {
	m->request = state;
	if(state == VERIFY) {
	  m->min = min;
	  m->max = max;
	}
	repeat--;
	if(repeat == 0) {
	  if(state == TRAINING)
	    state = MARZULLO;
	  if(state == VERIFY)
	    state = WAIT;
	  call MTimer.start(TIMER_ONE_SHOT,TEN_MIN);
	}
      }
      else
	m->request = 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
  
  // Operation when a DATA packet arrive
  // Add Data to the Marzullo structure
  result_t doData(TOS_MsgPtr rmsg) {
    struct CLNNMsg *datat;
    result_t r;
    
    datat = (struct CLNNMsg *)rmsg->data;

    // stop timer
    call MTimer.stop();

    // store mote data
    r = call Marzullolib.add_mote(datat);

    // start timer again
    call MTimer.start(TIMER_ONE_SHOT,TIMEOUT);
    return r;
  }

  // Operation when a FAILT packet arrive
  // Check if this is a fault mote
  result_t doOnce(TOS_MsgPtr rmsg) {
    struct CLNNMsg *datat;
    int16_t mote_id;
    int16_t fault;
    int8_t i;
    
    datat = (struct CLNNMsg *)rmsg->data;

    call MTimer.stop();
    
    mote_id = datat->src;
    fault = datat->f;

    for(i=0; i<nrecord; i++) {
      if(mote_id == record[i])
	break;
    }
    
    if(i != nrecord)
      return FAIL; // drop if not new pkt
    
    if(nrecord == MAX_MOTES)
      return FAIL;
    
    record[nrecord] = mote_id;
    nrecord++;

    if(fault > MAX_FAULTS)
      fault_mote++;
    
    call MTimer.start(TIMER_ONE_SHOT,TIMEOUT);
    return SUCCESS;
  }

  event TOS_MsgPtr RadioReceive.receive(TOS_MsgPtr Msg) {
    result_t print;
    uint8_t t= Msg->data[0];//type of the packet
    TOS_MsgPtr pBuf = Msg;

    print = FAIL;
    
    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):
      if(state == MARZULLO) {
        call Leds.greenToggle();
        print = doData(Msg); // on recving result from mote
      }
      if(state == WAIT) {       	
	print = doOnce(Msg);
	call Leds.yellowToggle();
	call MTimer.stop();
	call MTimer.start(TIMER_ONE_SHOT,TIMEOUT);
      }
      if(print == SUCCESS) {
	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;
  }
  
  // Marzullo Timeout
  event result_t MTimer.fired() {

    CLNNMsg *result;

    // The Verification Stage
    // Check # of fault mote, if > half -> retraining
    // else verify again
    if(state == WAIT) {
      if(nrecord == 0) {
	atomic {
	  state = TRAINING;
	  repeat = REPEAT_MSG;
	}
	return SUCCESS;
      }
      if(nrecord > 0 && nrecord-fault_mote >= fault_mote) {
	atomic {
	  nrecord = 0;
	  fault_mote = 0;
	  state = VERIFY;
	  repeat = REPEAT_MSG;
	}
	return SUCCESS;
      }
      atomic {
	state = TRAINING;
	repeat = REPEAT_MSG;
      }
      return SUCCESS;
    }

    // else if state == MARZULLO
    // doMarzullo and start verify

    marzullo_result.group = TOS_AM_GROUP;
    marzullo_result.addr = TOS_UART_ADDR;
    marzullo_result.length = TOSH_DATA_LENGTH;
    
    result = (struct CLNNMsg *)marzullo_result.data;
    // do marzullo
    result = call Marzullolib.doMarzullo(result);
    
    // if no Marzullo was done...
    if(result == NULL) {
      atomic {
	state = TRAINING;
	repeat = REPEAT_MSG;
      }
    }
    
    else {
      // set state to verify
      atomic {
	state = VERIFY;
	repeat = REPEAT_MSG;
	nrecord = 0;
	fault_mote = 0;
	min = result->min;
	max = result->max;

	radioQueue[radioOut]->group = TOS_AM_GROUP;
	radioQueue[radioOut]->addr = TOS_BCAST_ADDR;
	radioQueue[radioOut]->length = TOSH_DATA_LENGTH;
	
	// send result uart
	call UARTSend.send(&marzullo_result);
      }
    }
    
    // clear variables
    call Marzullolib.reset();
    
    return SUCCESS;
  }

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

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