maca.pc

simulator for ad hoc

        GLOMO_MsgFree(node, msg);
        break;
    }/*switch*/
}

void MacMacaReceiveRadioStatusChangeNotification(
   GlomoNode* node,
   GlomoMacMaca* maca,
   RadioStatusType oldRadioStatus,
   RadioStatusType newRadioStatus)
{
   if (oldRadioStatus == RADIO_TRANSMITTING) {
      assert(newRadioStatus != RADIO_TRANSMITTING);
      
      switch (maca->state) {
      case MACA_S_IN_XMITING_UNICAST: 
      {
          MacMacaResetTimer(node, maca);
          MacMacaSetState(node, maca, MACA_S_PASSIVE);
          MacMacaPassive(node, maca);
          break;
      }       
      case MACA_S_IN_XMITING_BROADCAST: 
      {
          MacMacaSetState(node, maca, MACA_S_YIELD);
          MacMacaYield(node, maca, MACA_VACATION);
          break;
      }
      case MACA_S_IN_XMITING_RTS: 
      {
          clocktype holdForCts;
   
          holdForCts = (3 * MAC_DELAY) + (2 * RADIO_PHY_DELAY) +
              (2 * SYNCHRONIZATION_TIME) +
              (2 * maca->myGlomoMac->propDelay) +
              (sizeof(MacaHeader) * SECOND) /
              maca->myGlomoMac->bandwidth +
              MACA_EXTRA_DELAY;
   
          MacMacaSetState(node, maca, MACA_S_RTS);
              
          MacMacaSetTimer(node, maca, MACA_T_RTS, holdForCts);
              
          break;
      }
      case MACA_S_IN_XMITING_CTS: 
      {
          clocktype holdForData;
   
          MacMacaSetState(node, maca, MACA_S_REMOTE);
   
          holdForData = (3 * MAC_DELAY) + (2 * RADIO_PHY_DELAY) +
                        (2 * SYNCHRONIZATION_TIME) +
                        (2 * maca->myGlomoMac->propDelay) +
                        ((maca->payloadSizeExpected +
                        sizeof(MacaHeader)) * SECOND) /
                        maca->myGlomoMac->bandwidth +
                        MACA_EXTRA_DELAY;
          
          MacMacaSetTimer(node, maca, MACA_T_REMOTE, holdForData);
          
          break;
      }
      default:
          assert(FALSE); abort();
          break;
      }/*switch*/
   }//if//
}



/*
 * FUNCTION    MacMacaLayer
 * PURPOSE     Models the behaviour of the MAC layer with the MACA protocol
 *             on receiving the message enclosed in msg.
 *
 * Parameters:
 *     node:     node which received the message
 *     msg:      message received by the layer
 */

void MacMacaLayer(GlomoNode *node, int interfaceIndex, Message *msg)
{
    /*
     * Retrieve the pointer to the data portion which relates
     * to the MACA protocol.
     */
    GlomoMacMaca *maca = (GlomoMacMaca *) node->macData[interfaceIndex]->macVar;
    int seqNo;
    
    assert(msg->eventType == MSG_MAC_TimerExpired);
            
    seqNo = *((int *) msg->info);
    GLOMO_MsgFree(node, msg);
    
    /* this timer has already been canceled */
    if ((seqNo < maca->timer.seq) ||
        ((maca->timer.flag &MACA_TIMER_SWITCH) == MACA_TIMER_OFF)) 
    {
        return;
    }
    
    assert(seqNo <= maca->timer.seq);
     
    switch (maca->timer.flag & MACA_TIMER_TYPE) {
    case MACA_T_RTS: 
    {
        MacMacaSetState(node, maca, MACA_S_BACKOFF);
        MacMacaBackoff(node, maca);
        
        break;
    }
    case MACA_T_BACKOFF:
    {
        MacMacaSetState(node, maca, MACA_S_PASSIVE);
        MacMacaPassive(node, maca);
        
        break;
    }
    case MACA_T_REMOTE: 
    {
        MacMacaSetState(node, maca, MACA_S_PASSIVE);
        MacMacaPassive(node, maca);
        
        break;
    }
    case MACA_T_YIELD: 
    {
        MacMacaCancelTimer(node, maca, MACA_T_UNDEFINED);
        MacMacaSetState(node, maca, MACA_S_PASSIVE);
        MacMacaPassive(node, maca);
        
        break;
    }
    default:
        break;
    }/*switch*/
}












//----------------------------------------------------------------------------
// Old Debug Code.
//
//MacMacaSetTimer(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(timerValue + simclock(), clockStr);
//    printf("MAC %u setting timer ", node->nodeAddr);
//
//    switch (maca->timer.flag & MACA_TIMER_TYPE)
//    {
//        case MACA_T_RTS:
//            printf("MACA_T_RTS");
//            break;
//        case MACA_T_BACKOFF:
//            printf("MACA_T_BACKOFF");
//            break;
//        case MACA_T_XMIT:
//            printf("MACA_T_XMIT");
//            break;
//        case MACA_T_REMOTE:
//            printf("MACA_T_REMOTE");
//            break;
//        case MACA_T_YIELD:
//            printf("MACA_T_YIELD");
//            break;
//        case MACA_T_UNDEFINED:
//            printf("MACA_T_UNDEFINED");
//            break;
//        default:
//            printf("MAC_MACA: Bad timer!\n");
//    }
//    
//    printf(" with seq %d at %s\n", maca->timer.seq, clockStr);
//    }
//    #endif
//
//
//
//MacMacaCancelTimer(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(simclock(), clockStr);
//    printf("MAC %u cancelling timer ", node->nodeAddr);
//
//    switch (maca->timer.flag & MACA_TIMER_TYPE)
//    {
//        case MACA_T_RTS:
//            printf("MACA_T_RTS");
//            break;
//        case MACA_T_BACKOFF:
//            printf("MACA_T_BACKOFF");
//            break;
//        case MACA_T_XMIT:
//            printf("MACA_T_XMIT");
//            break;
//        case MACA_T_REMOTE:
//            printf("MACA_T_REMOTE");
//                break;
//        case MACA_T_YIELD:
//            printf("MACA_T_YIELD");
//            break;
//        case MACA_T_UNDEFINED:
//            printf("MACA_T_UNDEFINED");
//            break;
//        default:
//            printf("MAC_MACA: Bad timer!\n");
//    }
//    
//    printf(" with seq %d at %s\n", maca->timer.seq, clockStr);
//    }
//    #endif
//}
//
//MacMacaSetState(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(simclock(), clockStr);
//    printf("MAC %u setting state to ", node->nodeAddr);
//
//    switch(maca->state)
//    {
//        case MACA_S_PASSIVE:
//            printf("MACA_S_PASSIVE");
//            break;
//        case MACA_S_RTS:
//            printf("MACA_S_RTS");
//            break;
//        case MACA_S_BACKOFF:
//            printf("MACA_S_BACKOFF");
//            break;
//        case MACA_S_REMOTE:
//            printf("MACA_S_REMOTE");
//            break;
//        case MACA_S_XMIT:
//            printf("MACA_S_XMIT");
//            break;
//        case MACA_S_YIELD:
//            printf("MACA_S_YIELD");
//            break;
//        case MACA_S_IN_XMITING_RTS:
//            printf("MACA_S_IN_XMITING_RTS");
//            break;
//        case MACA_S_IN_XMITING_CTS:
//            printf("MACA_S_IN_XMITING_CTS");
//            break;
//        case MACA_S_IN_XMITING_UNICAST:
//            printf("MACA_S_IN_XMITING_UNICAST");
//            break;
//        case MACA_S_IN_XMITING_BROADCAST:
//            printf("MACA_S_IN_XMITING_BROADCAST");
//            break;
//        default:
//            printf("MAC_MACA: Bad state");
//            break;
//    }
//    
//    printf(" at %s\n", clockStr);
//    }
//    #endif
//
//MacMacaYield(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(vacation, clockStr);
//    printf("MAC %u yielding for %s ", node->nodeAddr, clockStr);
//    ctoa(simclock(), clockStr);
//    printf("at %s\n", clockStr);
//    ctoa(simclock() + vacation, clockStr);
//    printf("        timeout at %s\n", clockStr);
//    }
//    #endif
//
//
//MacMacaSendCts(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(simclock(), clockStr);
//    printf("MAC %u transmitting CTS of size %d with payload of %d at %s\n",
//           node->nodeAddr, msg->packetSize, hdr->payloadSize, clockStr);
//    }
//    #endif
//
//MacMacaGetData(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(simclock(), clockStr);
//    printf("MAC %u sending packet of size %d to NETWORK at %s\n",
//           node->nodeAddr, msg->packetSize - sizeof(MacaHeader), clockStr);
//    }
//    #endif
//
//
//MacMacaRts(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(simclock(), clockStr);
//    printf("MAC %u sending RTS of size %d with payload size of %d at %s\n", 
//           node->nodeAddr, msg->packetSize, hdr->payloadSize, clockStr);
//    }
//    #endif
//
//
//MacMacaDataXmit(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(simclock(), clockStr);
//    printf("MAC %u sending DATA of size %d with payload size of %d "
//           "at %s\n", node->nodeAddr, msg->packetSize,
//           msg->packetSize - sizeof(MacaHeader), clockStr);
//    }
//    #endif
//
//
//MacMacaBackoff(
//    #ifdef DEBUG
//    {
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(randomTime, clockStr);
//    printf("MAC %u backing off for %s\n",
//           node->nodeAddr, clockStr);
//    }
//    #endif
//
//
//MacMacaRemote(
//                #ifdef DEBUG
//                {
//                char clockStr[GLOMO_MAX_STRING_LENGTH];
//                ctoa(holdForCtsData, clockStr);
//                printf("MAC %u holding for CTS and DATA for %s\n",
//                       node->nodeAddr, clockStr);
//                ctoa(simclock() + holdForCtsData, clockStr);
//                printf("    timeout at %s\n", clockStr);
//                }
//                #endif
//
//
//            #ifdef DEBUG
//            {
//            char clockStr[GLOMO_MAX_STRING_LENGTH];
//            ctoa(holdForData, clockStr);
//            printf("MAC %u holding for DATA for %s\n",
//                   node->nodeAddr, clockStr);
//            ctoa(simclock() + holdForData, clockStr);
//            printf("    timeout at %s\n", clockStr);
//            }
//            #endif
//
//
//    char clockStr[GLOMO_MAX_STRING_LENGTH];
//    ctoa(simclock(), clockStr);
//
//MacMacaLayer(
//            #ifdef DEBUG
//            {
//            char clockStr[GLOMO_MAX_STRING_LENGTH];
//            ctoa(simclock(), clockStr);
//            printf("MAC %u got frame of type %d from radio at %s\n",
//                   node->nodeAddr, frameType, clockStr);
//            }
//            #endif
//            
//                    
//                    #ifdef DEBUG
//                    {
//                    char clockStr[GLOMO_MAX_STRING_LENGTH];
//                    ctoa(holdForCts, clockStr);
//                    printf("MAC %u holding for CTS for %s\n",
//                           node->nodeAddr, clockStr);
//                    ctoa(simclock() + holdForCts, clockStr);
//                    printf("    timeout at %s\n", clockStr);
//                    }
//                    #endif
//
//                    #ifdef DEBUG
//                    {
//                    char clockStr[GLOMO_MAX_STRING_LENGTH];
//                    ctoa(holdForData, clockStr);
//                    printf("MAC %u holding for DATA for %s\n",
//                           node->nodeAddr, clockStr);
//                    ctoa(simclock() + holdForData, clockStr);
//                    printf("    timeout at %s\n", clockStr);
//                    }
//                    #endif
//
//            
//            #ifdef DEBUG
//            printf("MAC %u timer expired of type ", node->nodeAddr);
//            
//            switch (maca->timer.flag & MACA_TIMER_TYPE)
//            {
//                case MACA_T_RTS:
//                    printf("MACA_T_RTS");
//                    break;
//                case MACA_T_BACKOFF:
//                    printf("MACA_T_BACKOFF");
//                    break;
//                case MACA_T_XMIT:
//                    printf("MACA_T_XMIT");
//                    break;
//                case MACA_T_REMOTE:
//                    printf("MACA_T_REMOTE");
//                    break;
//                case MACA_T_YIELD:
//                    printf("MACA_T_YIELD");
//                    break;
//                case MACA_T_UNDEFINED:
//                    printf("MACA_T_UNDEFINED");
//                    break;
//                default:
//                    printf("MAC_MACA: Bad timer!\n");
//            }
//            
//            printf("\n");
//            #endif
//