csmamacp.nc

tinyos2.0版本驱动

        atomic {
            if (macState != RX) {
                post StopDone();
                storeOldState(2);
            } else {
                storeOldState(3);
                call Timer.stop();
                call Init.init();
                signal SplitControl.stopDone(SUCCESS); 
            }
        }
    }
    
    command error_t SplitControl.stop() {
        call CcaStdControl.stop();
        storeOldState(4);
        post StopDone();
        return SUCCESS;
    }
    
    /****** Packet interface ********************/
    command void Packet.clear(message_t* msg) {
        call SubPacket.clear(msg);
    }
    
    command uint8_t Packet.payloadLength(message_t* msg) {
        return call SubPacket.payloadLength(msg);
    }
    
    command void Packet.setPayloadLength(message_t* msg, uint8_t len) {
        call SubPacket.setPayloadLength(msg,len);
    }
    
    command uint8_t Packet.maxPayloadLength() {
        return call SubPacket.maxPayloadLength();
    }
    
    command void* Packet.getPayload(message_t* msg, uint8_t len) {
        return call SubPacket.getPayload(msg, len);
    }
   
    /****** Radio(Mode) events *************************/
    async event void RadioModes.RssiStable() {
        atomic  {
            setFlag(&flags, RSSI_STABLE);
            if(macState == INIT) {
                storeOldState(11);
                if(call RssiAdcResource.isOwner()) {
                    call ChannelMonitorControl.updateNoiseFloor();
                }
            }
            else {
                storeOldState(12);
            }
        }
    }

    async event void RadioModes.RxModeDone() {
        post postponeReRx();
        atomic {
            if(macState == SW_RX) {
                storeOldState(21);
                macState = RX;
                signalMacState();
                if(isFlagSet(&flags, RESUME_BACKOFF)) {
                    clearFlag(&flags, RESUME_BACKOFF);
                    call Timer.start(restLaufzeit);
                } else {
                    call Timer.start(backoff(longRetryCounter));
                }
            }
            else if(macState == SW_RX_ACK) {
                storeOldState(22);
                macState = RX_ACK;
                signalMacState();
            }
            else if(macState == INIT) {
                storeOldState(24);
            }
            else {
                storeOldState(25);
                signalFailure(1);
            }
        }
    }

    async event void RadioModes.TxModeDone() {
        post postponeReRx();
        atomic {
            if(macState == SW_TX) {
                storeOldState(30);
                if(txBufPtr) {
                    macState = TX;
                    signalMacState();
                    if(call PacketSend.send(txBufPtr, txLen) == SUCCESS) {
                        storeOldState(31);
                    } else {
                        storeOldState(32);
                        signalFailure(2);
                    }
                }
            }
            else if(macState == SW_TX_ACK) {
                macState = TX_ACK;
                signalMacState();
                if(call PacketSend.send(&ackMsg, 0) == SUCCESS) {
                    storeOldState(53);
                } else {
                    storeOldState(54);
                    signalFailure(6);
                }
            }
            else {
                storeOldState(33);
                signalFailure(3);
            }
        }
    }

    /****** MacSend events *************************/    
    async command error_t MacSend.send(message_t* msg, uint8_t len) {
        error_t err = SUCCESS;
        atomic {
            if((shortRetryCounter == 0) && (txBufPtr == NULL) && (macState != INIT)) { 
              storeOldState(40);
                shortRetryCounter = 1;
                longRetryCounter = 1;
                txBufPtr = msg;
                txLen = len;
                seqNo++;
                if(seqNo >= TOKEN_ACK_FLAG) seqNo = 1;
                getHeader(msg)->token = seqNo;
                if(needsAckTx(msg)) getHeader(msg)->token |= ACK_REQUESTED;
                if(macState != RX_P) checkSend();
            }
            else {
                storeOldState(41);
                err = EBUSY;
            }
        }
        return err;
    }

    async command error_t MacSend.cancel(message_t* msg) {
        error_t err = SUCCESS;
        if((shortRetryCounter != 0) && (txBufPtr == msg) &&
           (macState != TX) && (macState != RX_ACK) && (macState != SW_RX_ACK)) {
            storeOldState(50);
            shortRetryCounter = 0;
            txBufPtr = NULL;
            txLen = 0;
            signal MacSend.sendDone(msg, ECANCEL);
        }
        else {
            storeOldState(51);
            err = FAIL;
        }
        return err;
    }
    
    /****** PacketSerializer events **********************/
    async event void PacketReceive.receiveDetected() {
        rssiValue = INVALID_SNR;
        if(macState <= RX_ACK) {
            storeOldState(60);
            interruptBackoffTimer();
            if(macState == CCA) computeBackoff();
        }
        if(macState <= RX) {
            storeOldState(61);
            macState = RX_P;
            signalMacState();
            requestAdc();
        }
        else if(macState <= RX_ACK) {
            storeOldState(62);
            macState = RX_ACK_P;
            signalMacState();
        }
        else if(macState == INIT) {
            storeOldState(63);
        }
        else {
          post ReleaseAdcTask();  
          storeOldState(64);
          signalFailure(4);	
        } 
    }
    
    async event message_t* PacketReceive.receiveDone(message_t* msg, void* payload, uint8_t len, error_t error) {
        message_t* m = msg;
        bool isCnt;
        macState_t action = RX;
        if(macState == RX_P) {
            if(error == SUCCESS) {
                storeOldState(82);
                isCnt = isControl(msg);
                if(msgIsForMe(msg)) {
                    if(!isCnt) {
                        storeStrength(msg);
                        if(isNewMsg(m)) {
                            m = signal MacReceive.receiveDone(msg);
                            rememberMsg(m);   
                        }
                        if(needsAckRx(msg)) {
                            storeOldState(87);
                            action = CCA_ACK;
                        } else {
                            storeOldState(88);
                        }
                    }
                    else {
                        storeOldState(89);
                    }
                }
                else {
                    storeOldState(90);
                }
            }
            else {
                storeOldState(91);
            }
        }
        else if(macState == RX_ACK_P) {
            if(error == SUCCESS) {
                if(ackIsForMe(msg)) {
                    storeOldState(92);
                    (getMetadata(txBufPtr))->ack = WAS_ACKED;
                    signalSendDone(SUCCESS);
                }
                else {
                    storeOldState(93);
                    updateLongRetryCounters();
                }
            }
            else {
                if(call Timer.isRunning()) {
                    storeOldState(94);
                    action = RX_ACK;
                }
                else {
                    storeOldState(95);
                    if(needsAckTx(txBufPtr)) {
                        updateLongRetryCounters();
                    }
                    else {
                        signalSendDone(SUCCESS);
                    }
                }
            }
        }
        else if(macState == INIT) {
            action = INIT;
        }
        if(action == CCA_ACK) {
            prepareAck(msg);
            macState = CCA_ACK;
            signalMacState();
            call Timer.start(RX_SETUP_TIME - TX_SETUP_TIME + ADDED_DELAY);
        }
        else if(action == RX_ACK) {
            macState = RX_ACK;
            signalMacState();
        }
        else if(action == RX) {
            macState = RX;
            signalMacState();
            if(isFlagSet(&flags, RESUME_BACKOFF)) {
                clearFlag(&flags, RESUME_BACKOFF);
                call Timer.start(restLaufzeit);
            }
            else {
                call Timer.start(backoff(longRetryCounter));
            }
        }
        else if(action == TX) {
            macState = SW_TX;
            signalMacState();
            setTxMode();
        }
        else if(action == INIT) {
            
        }
        else {
            storeOldState(94);
            signalFailure(11);
        }
        post ReleaseAdcTask();
        return m;        
    }

    async event void PacketSend.sendDone(message_t* msg, error_t error) {
        if(macState == TX) {
            if(msg != txBufPtr) signalFailure(12);
            if(needsAckTx(msg)) {
                storeOldState(97);
                macState = SW_RX_ACK;
                signalMacState();
                call Timer.start(RX_ACK_TIMEOUT);
            } else {
                storeOldState(99);
                signalSendDone(error);
                macState = SW_RX;
                signalMacState();
            }
            setRxMode();
        }
        else if(macState == TX_ACK) {
            macState = SW_RX;
            signalMacState();
            setRxMode();
        }
        else {
            signalFailure(13);
        }
        post ReleaseAdcTask();
    }
       
    
    /****** Timer ******************************/
    void checkOnBusy() {
        if(macState == CCA) {
            computeBackoff();
            macState = RX;
            requestAdc();
            storeOldState(150);
            signalMacState();
            if(!call Timer.isRunning()) call Timer.start(TX_GAP_TIME >> 1);
        } else if(macState == RX) {
            if(!call Timer.isRunning()) call Timer.start(TX_GAP_TIME + backoff(0));
        }
    }

    void checkOnIdle()  {
        if(macState == RX) {
            checkSend();
        }
        else if(macState == CCA) {
            checkCounter++;
            if(checkCounter < 3) {
                storeOldState(158);                
                call Timer.start((TX_GAP_TIME + backoff(0))>>1);
                requestAdc();
            }
            else {
                call Timer.stop();
                storeOldState(159);
                macState = SW_TX;
                signalMacState();
                setTxMode();
            }
        }
    }
    
    async event void Timer.fired() {
        storeOldState(100);
        if(macState == CCA) {
            if((!call RssiAdcResource.isOwner()) || (call ChannelMonitor.start() != SUCCESS)) {
                if(call UartPhyControl.isBusy()) {
                    storeOldState(101);
                    checkOnBusy();
                }
                else {
                    storeOldState(102);
                    checkOnIdle();
                }
            } else {
              setFlag(&flags, CCA_PENDING);
            }
        }
        else if(macState == RX_ACK) {
            if(needsAckTx(txBufPtr)) {
                storeOldState(103);
                updateLongRetryCounters();
                macState = RX;
                call Timer.start(backoff(longRetryCounter));
            }
            else {
                storeOldState(104);
                signalFailure(7);                
            }
        }
        else if(macState == CCA_ACK) {
            storeOldState(160);
            macState = SW_TX_ACK;
            signalMacState();
            setTxMode();
        }
        else if((macState == RX_ACK_P) || (macState == RX_P)) {
            storeOldState(108);
        }
        else if(macState == INIT) {
            storeOldState(109);
            post StartDoneTask();
        }
        else {
            storeOldState(110);
            checkSend();
        }
    }
    
    /****** ChannelMonitor events *********************/

    async event void ChannelMonitor.channelBusy() {
      clearFlag(&flags, CCA_PENDING);  
      storeOldState(120);
        checkOnBusy();
    }

    async event void ChannelMonitor.channelIdle() {
      clearFlag(&flags, CCA_PENDING);  
      storeOldState(121);
        checkOnIdle();
    }


    /****** ChannelMonitorControl events **************/
    
    event void ChannelMonitorControl.updateNoiseFloorDone() {
        if(macState == INIT) {
            storeOldState(122);
            post StartDoneTask();
        } else {
            storeOldState(124);
            signalFailure(11);
        }
    }

    /***** ChannelMonitorData events ******************/
    
    async event void ChannelMonitorData.getSnrDone(int16_t data) {
        atomic if((macState == RX_P) || (macState == RX_ACK_P)) rssiValue = data;
        post ReleaseAdcTask();  
    }
    
    /***** unused Radio Modes events **************************/
    
    async event void RadioModes.TimerModeDone() {}

    async event void RadioModes.SleepModeDone() {
        atomic setRxMode();
    }
    
    async event void RadioModes.SelfPollingModeDone() {}
    async event void RadioModes.PWDDDInterrupt() {}

    event void ReRxTimer.fired() {
        atomic {
            if((macState == RX) && (call RadioModes.SleepMode() == SUCCESS)) {
                // ok 
            }
            else {
                post postponeReRx();
            }
        }
    }
    
    /***** abused TimeStamping events **************************/
    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();
        }
    }
    
    async event void RadioTimeStamping.transmittedSFD( uint16_t time, message_t* p_msg ) {}

    /***** Rssi Resource events ******************/
    event void RssiAdcResource.granted() {
        macState_t ms;
        atomic ms = macState;
        if((ms == INIT) && isFlagSet(&flags, RSSI_STABLE)) {
            storeOldState(145);
            call ChannelMonitorControl.updateNoiseFloor();            
        }
        else {
            storeOldState(146);
            call RssiAdcResource.release();
        }
    }
    
    /***** RadioData Resource events **************/
    async event void RadioResourceRequested.requested() {
      atomic {
        /* This gives other devices the chance to get the Resource
           because RxMode implies a new arbitration round.  */
        if (macState == RX) setRxMode();
      }
    }
    
    // we don't care about urgent Resource requestes
    async event void RadioResourceRequested.immediateRequested() {}
}