redmacp.nc

tinyos2.0版本驱动

                        if(needsAckRx(msg, &level) && (action != RX)) {
                            action = CCA_ACK;
                            if(level == 2) {
                                getMetadata(msg)->ack = WAS_ACKED;
                            }
                        }
                        else {
                            // sdDebug(198);
                            if(action != RX) {
                                nav = ((red_mac_header_t*)payload)->repetitionCounter *
                                    (SUB_HEADER_TIME + getHeader(msg)->length*BYTE_TIME +
                                     SUB_FOOTER_TIME + RX_ACK_TIMEOUT + TX_SETUP_TIME) + ACK_DURATION;
                                action = SLEEP;
                            }
                        }
                    }
                    else {
                        // sdDebug(199);
                        action = RX;
                    }
                }
                else {
                    // sdDebug(200);
                    action = SLEEP;
                    if(!isCnt) {
                        nav = ((red_mac_header_t*)payload)->repetitionCounter *
                            (SUB_HEADER_TIME + getHeader(msg)->length*BYTE_TIME +
                             SUB_FOOTER_TIME + RX_ACK_TIMEOUT + TX_SETUP_TIME) +
                            ACK_DURATION;
                    }
                }
            }
            else {
                // sdDebug(201);
                action = SLEEP;
            }
        }
        else if(macState == RX_ACK_P) {
            if(error == SUCCESS) {
                if(ackIsForMe(msg)) {
                    // sdDebug(202);
                    getMetadata(txBufPtr)->ack = WAS_ACKED;
                    getMetadata(txBufPtr)->repetitions = txMacHdr->repetitionCounter;
                    if(isFlagSet(&flags, TEAMGEIST_ACTIVE) &&
                       (getHeader(txBufPtr)->type == teamgeistType))
                    {
                        signal Teamgeist.gotAck(txBufPtr, getHeader(msg)->src,
                                                getMetadata(txBufPtr)->strength);
                    }
                    // sdDebug(203);
                    signalSendDone(SUCCESS);
                    // sdDebug(30000 + getHeader(msg)->src);
                    action = SLEEP;
                }
                else {
                    // sdDebug(203);
                    updateLongRetryCounters(); // this will eventually schedule the right backoff
                    macState = SLEEP;          // so much traffic is going on -- take a nap
                    setSleepMode();
                    action = INIT;             // a difficult way to say: do nothing
                }
            }
            else {
                if(call Timer.isRunning()) {
                    // sdDebug(204);
                    action = RX_ACK;
                }
                else {
                    // sdDebug(205);
                    updateLongRetryCounters();
                    action = RX;
                }
            }
        }
        else {
            // sdDebug(206);
            action = INIT;
        }
        if(action == CCA_ACK) {
            macState = CCA_ACK;
            if(call Random.rand16() & 2) {
                call Timer.start(RX_SETUP_TIME - TX_SETUP_TIME + 16 - level*8 + ADDED_DELAY);
            }
            else {
                macState = TX_ACK;
                call Timer.start(RX_SETUP_TIME - TX_SETUP_TIME + 16);
            }
            prepareAck(msg);
        }
        else if(action == RX_ACK) {
            macState = RX_ACK;
        }
        else if(action == RX) {
            macState = RX;
            checkCounter = 0;
            call Timer.start(DATA_DETECT_TIME);
        }
        else if(action == SLEEP) {
            macState = SLEEP;
            if(isFlagSet(&flags, RESUME_BACKOFF)) {
                nav = nav*(uint32_t)ADD_NAV/(uint32_t)NAV_FACTOR;
                if(nav > restLaufzeit) restLaufzeit += nav;
            }
            else {
                setFlag(&flags, RESUME_BACKOFF);
                restLaufzeit = call Random.rand16() & ZERO_BACKOFF_MASK;
            }
            setSleepMode();
        }
        else if(action == INIT) {
            clearFlag(&flags, UNHANDLED_PACKET);
        }
        else {
            // sdDebug(207);
        }
#ifdef REDMAC_PERFORMANCE
        if(error == SUCCESS) {
            rxStat.type = getHeader(msg)->type;
            rxStat.from = getHeader(msg)->src;
            rxStat.to = getHeader(msg)->dest;
            rxStat.token = getHeader(msg)->token;
            if(!isControl(msg)) rxStat.repCounter  = ((red_mac_header_t*)payload)->repetitionCounter;
            rxStat.payloadLength = len;
            rxStat.strength = rssiValue;
            rxStat.creationTime = getMetadata(msg)->time;
            call Performance.macRxStats(&rxStat);
        }
#endif
        return m;
    }

    async event void PacketSend.sendDone(message_t* msg, error_t error) {
        if(macState == TX) {
            macState = RX_ACK;
            setRxMode();
            call Timer.start(RX_ACK_TIMEOUT);
            // sdDebug(220);
            checkCounter = 0;
        }
        else if(macState == TX_ACK) {
            checkCounter = 0;
            macState = SLEEP;
            setSleepMode();
            // macState = RX;
            // setRxMode();
            // sdDebug(221);
#ifdef REDMAC_DEBUG            
            // sdDebug(40000U + repCounter);
#endif
        }
    }
    
    /***** TimeStamping stuff **************************/
    async event void RadioTimeStamping.receivedSFD( uint16_t time ) {
        if(call RssiAdcResource.isOwner()) call ChannelMonitorData.getSnr();
        if(macState == RX_P) {
            rxTime = call LocalTime32kHz.get();
            call ChannelMonitor.rxSuccess();
            sdDebug(221);
        }
    }
    
    async event void RadioTimeStamping.transmittedSFD( uint16_t time, message_t* p_msg ) {
        if((macState == TX) && (p_msg == txBufPtr)) {
#ifdef DELTATIMEDEBUG
            dTrace.now = call LocalTime32kHz.get();
            dTrace.msgTime = getMetadata(p_msg)->time;
            dTrace.delta = call TimeDiff32.computeDelta(dTrace.now, dTrace.msgTime);
            txMacHdr->time = dTrace.delta;
            call DeltaTrace.traceTx(&dTrace);
#else
            txMacHdr->time =
                call TimeDiff32.computeDelta(call LocalTime32kHz.get(), getMetadata(p_msg)->time);
#endif
        }
    }
    
    /****** Timer ******************************/

    void checkOnBusy() {
        setFlag(&flags, ACTION_DETECTED);
        if((macState == RX) || (macState == CCA) || (macState == CCA_ACK)) {
            if(macState == CCA) {
                computeBackoff();
#ifdef REDMAC_PERFORMANCE
                call Performance.macBusyOnCca();
#endif
            }
            requestAdc();
            // sdDebug(230);
            macState = RX;
            checkCounter = 0;
            call Timer.start(TX_GAP_TIME>>1);
        }
    }

    void checkOnIdle()  {
        if(macState == RX) {
            checkCounter++;
            if(checkCounter >= 3) {
                // sdDebug(240);
                macState = SLEEP;
                setSleepMode();
            }
            else {
                // sdDebug(241);
                call Timer.start(TX_GAP_TIME >> 1);
                requestAdc();
            }
        }
        else if(macState == CCA) {
            checkCounter++;
            if(checkCounter < 3) {
                // sdDebug(242);                
                call Timer.start(TX_GAP_TIME >> 1);
                requestAdc();
            }
            else {
                // sdDebug(243);
                macState = TX;
                setTxMode();
#ifdef REDMAC_PERFORMANCE
                call Performance.macIdleOnCca();
                txStat.txModeTime = call LocalTime32kHz.get();
#endif
            }
        }
        else if(macState == CCA_ACK) {
            // sdDebug(244);
            macState = TX_ACK;
            setTxMode();
            // sdDebug(20000 + getHeader(&ackMsg)->dest);
#ifdef REDMAC_PERFORMANCE
            call Performance.macTxAckStats(getHeader(&ackMsg)->type,
                                          getHeader(&ackMsg)->dest,
                                          getHeader(&ackMsg)->token);
#endif
        }
    }
    
    async event void Timer.fired() {
        // sdDebug(250);
        if((macState == RX) || (macState == CCA) || (macState == CCA_ACK)) {
            if((!call RssiAdcResource.isOwner()) || (call ChannelMonitor.start() != SUCCESS)) {
                if(call UartPhyControl.isBusy()) {
                    // sdDebug(251);
                    checkOnBusy();
                }
                else {
                    // sdDebug(252);
                    checkOnIdle();
                }
            }
        }
        else if(macState == RX_ACK) {
            if(prepareRepetition()) {
                // sdDebug(253);
                macState = TX;
                setTxMode();
            }
            else {
                if(needsAckTx(txBufPtr)) {
                    // sdDebug(254);
#ifdef REDMAC_PERFORMANCE
                    call Performance.macAckTimeout();
#endif
                    updateLongRetryCounters();
                }
                else {
                    // sdDebug(255);
                    signalSendDone(SUCCESS);
                }
                macState = SLEEP;
                setSleepMode();
            }
        }
        else if(macState == TX_ACK) {
            setTxMode();
            // sdDebug(10000 + getHeader(&ackMsg)->dest);
        }
        else if(macState == SLEEP) {
             if(isFlagSet(&flags, SWITCHING)) {
                 // sdDebug(256);
                 call Timer.start(call Random.rand16() & 0x0f);
             }
             else {
                 if(isFlagSet(&flags, RESUME_BACKOFF)) {
                     // sdDebug(261);
                     clearFlag(&flags, RESUME_BACKOFF);
                     call Timer.start(restLaufzeit);
                     restLaufzeit = 0;
                 }
                 else {
                     // sdDebug(262);
                     checkSend();
                 }
             }
        }
        else if((macState == RX_ACK_P) || (macState == RX_P)) {
            // sdDebug(258);
        }
        else if(macState == INIT) {
            // sdDebug(259);
            post StartDoneTask();
        }
        else {
            // sdDebug(260);
        }
    }
    
    /****** SampleTimer ******************************/
    async event void SampleTimer.fired() {
        call SampleTimer.start(localSleeptime);
        // sdDebug(270);
        if((macState == SLEEP) && (!isFlagSet(&flags, SWITCHING))) {
            clearFlag(&flags, ACTION_DETECTED);
            interruptBackoffTimer();
            macState = RX;
            // sdDebug(271);
            setRxMode();
            call Timer.stop();
        }
    }

    /***** Sleeptime **********************************/
    async command void Sleeptime.setLocalSleeptime(uint16_t sT) {
        atomic localSleeptime = sT;
    }

    async command uint16_t Sleeptime.getLocalSleeptime() {
        uint16_t st;
        atomic st = localSleeptime;
        return st;        
    }

    async command void Sleeptime.setNetworkSleeptime(uint16_t sT) {
        atomic {
            networkSleeptime = sT;
            for(MIN_BACKOFF_MASK = 1; MIN_BACKOFF_MASK < sT; ) {
                MIN_BACKOFF_MASK = (MIN_BACKOFF_MASK << 1) + 1;
            }
            MIN_BACKOFF_MASK >>= 3;
        }
    }
    
    async command uint16_t Sleeptime.getNetworkSleeptime() {
        uint16_t st;
        atomic st = networkSleeptime;
        return st;
    }

    /****** ChannelMonitor events *********************/

    async event void ChannelMonitor.channelBusy() {
        // sdDebug(280);
        checkOnBusy();
    }

    async event void ChannelMonitor.channelIdle() {
        // sdDebug(281);
        checkOnIdle();
    }

    /****** ChannelMonitorControl events **************/
    
    event void ChannelMonitorControl.updateNoiseFloorDone() {
        if(macState == INIT) {
            // sdDebug(290);
            call Timer.start(call Random.rand16() % localSleeptime);
            setSleepMode();
        } else {
            // sdDebug(291);
        }
    }

    /***** ChannelMonitorData events ******************/
    
    async event void ChannelMonitorData.getSnrDone(int16_t data) {
        atomic if((macState == RX_P) || (macState == RX_ACK_P)) rssiValue = data;
    }
    
    /***** Rssi Resource events ******************/
    event void RssiAdcResource.granted() {
        macState_t ms;
        atomic ms = macState;
        if(ms < SLEEP) {
            // sdDebug(300);
        }
        else if(ms == INIT) {
            // sdDebug(301);
            call ChannelMonitorControl.updateNoiseFloor();            
        }
        else {
            // sdDebug(302);
            post ReleaseAdcTask();
        }
    }
    
    /***** default Teamgeist events **************************/

    default event am_id_t Teamgeist.observedAMType() {
        clearFlag(&flags, TEAMGEIST_ACTIVE);
        return teamgeistType;
    }

    default async event bool Teamgeist.needsAck(message_t *msg, am_addr_t src, am_addr_t dest, uint16_t snr) {
        clearFlag(&flags, TEAMGEIST_ACTIVE);
        return TRUE;
    }

    default async event uint8_t Teamgeist.estimateForwarders(message_t *msg) {
        return 1;
    }

    default async event am_addr_t Teamgeist.getDestination(message_t *msg, uint8_t retryCounter) {
        return getHeader(msg)->dest;
    }
    
    default async event void Teamgeist.gotAck(message_t *msg, am_addr_t ackSender, uint16_t snr) {
    }
    
    default async event void ChannelCongestion.congestionEvent(uint8_t level) {}

    /***** Mac Eval *******************************************/
#ifdef MAC_EVAL
    async command void MacEval.setBackoffMask(uint16_t mask) {
        atomic MIN_BACKOFF_MASK = mask;
    }
    async command void MacEval.increaseBackoff(bool value) {
        atomic INCREASE_BACKOFF = value;
    }
    async command void MacEval.addNav(uint8_t value) {
        atomic ADD_NAV = value;
    }
    async command void MacEval.setLongRetry(uint8_t lr) {
        atomic MAX_LONG_RETRY = lr;
    }
    async command void MacEval.setShortRetry(uint8_t sr) {
        atomic MAX_SHORT_RETRY = sr;
    }    
#endif
    
    /***** unused Radio Modes events **************************/
    async event void RadioModes.TimerModeDone() {}
    async event void RadioModes.SelfPollingModeDone() {}
    async event void RadioModes.PWDDDInterrupt() {}
}