csmamacp.nc

来自「tinyos-2.0源代码！转载而已！要的尽管拿！」· NC 代码 · 共 661 行 · 第 1/2 页

            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;
    }
    
    /****** Radio(Mode) events *************************/
    async event void RadioModes.RssiStable() {
        atomic  {
            setFlag(&flags, RSSI_STABLE);
            if(macState == SW_CCA)  {
                storeOldState(10);
                macState = CCA;
                signalMacState();
                call Timer.start(DIFS);
                call ChannelMonitor.start();
            } else if(macState == INIT) {
                storeOldState(11);
                call ChannelMonitorControl.updateNoiseFloor();
            } else {
                storeOldState(13);
            }
        }
    }

    async event void RadioModes.RxModeDone() {
        atomic {
            if(macState == SW_RX) {
                storeOldState(21);
                macState = RX;
                signalMacState();
                call Timer.start(backoff());
            }
            else if(macState == SW_RX_ACK) {
                storeOldState(22);
                macState = RX_ACK;
                signalMacState();
                call Timer.start(ACK_TIMEOUT);
            }
            else if(macState == SW_CCA) {
                storeOldState(23);
            }
            else if(macState == INIT) {
                storeOldState(24);
            }
            else {
                storeOldState(25);
                signalFailure(1);
            }
        }
    }

    async event void RadioModes.TxModeDone() {
        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 {
                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)) {
                storeOldState(40);
                shortRetryCounter = 1;
                txBufPtr = msg;
                txLen = len;
                if((macState != RX_P) && (macState != RX_ACK)) 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() {
        if(macState <= RX_ACK) {
            storeOldState(60);
            rssiValue = 0xFFFF;
            call Timer.stop();
            clearFlag(&flags, CHECK_RX_LIVENESS);
            if(isFlagSet(&flags, BUSY_DETECTED_VIA_RSSI)) call ChannelMonitor.rxSuccess();
            call  ChannelMonitorData.getSnr();
        }
        if(macState <= RX) {
            storeOldState(61);
            macState = RX_P;
            signalMacState();
        }
        else if(macState <= RX_ACK) {
            storeOldState(62);
            macState = RX_ACK;
            signalMacState();
        }
        else if(macState == INIT) {
            storeOldState(63);
        }
        else {
            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;
        if(macState == RX_P) {
            storeOldState(70);
            if (error == SUCCESS) {
                storeOldState(71);
                (getMetadata(msg))->strength = rssiValue;
                m = signal MacReceive.receiveDone(msg);
            }
            macState = RX;
            signalMacState();
            call Timer.start(backoff());
        }
        else if(macState == RX_ACK) {
            storeOldState(72);
            if(txBufPtr == NULL) signalFailure(5);
            if((error == SUCCESS) &&
               getFooter(msg)->crc &&
               (getHeader(msg)->type == CSMA_ACK) &&
               (*((uint16_t*)(msg->data)) == TOS_NODE_ID))
            {
                storeOldState(73);
                getMetadata(txBufPtr)->ack = 1;
                signalSendDone(SUCCESS);
            }
            else {
                storeOldState(74);
                updateRetryCounters();
            }
            macState = RX;
            signalMacState();
            call Timer.start(backoff());
        } else {
            storeOldState(76);
        }
        return m;
    }

    async event void PacketSend.sendDone(message_t* msg, error_t error) {
        if(macState == TX) {
            if(msg != txBufPtr) signalFailure(7);            
            if(needsAck(msg)) {
                if(error == SUCCESS) {
                    storeOldState(80);
                    macState = SW_RX_ACK;
                    signalMacState();
                } else {
                    storeOldState(81);
                    macState = SW_RX;
                    signalMacState();
                }
            } else {
                macState = SW_RX;
                signalMacState();
                signalSendDone(error);
            }
        }
        else if(macState == TX_ACK) {
            storeOldState(83);
            if(msg != &ackMsg) signalFailure(8);
            macState = SW_RX;
            signalMacState();
        }
        else {
            storeOldState(84);
            signalFailure(9);
        }
        setRxMode();
    }
       
    
    /****** Timer ******************************/
    
    async event void Timer.fired() {
        if(macState == RX) {
            storeOldState(90);
            if(isFlagSet(&flags, CHECK_RX_LIVENESS)) {
                /* if(call UartPhyControl.isBusy()) {
                    call Timer.start(CHECK_RX_LIVENESS_INTERVALL);
                }
                else {
                */
                    call ChannelMonitor.start();
                    /*} */
            } else {
                checkSend();
            }
        }
        else if(macState == RX_ACK) {
            storeOldState(91);
            updateRetryCounters();
            macState = RX;
            signalMacState();
            call Timer.start(backoff());
        }
        else if(macState == CCA) {
            storeOldState(92);
            setFlag(&flags, DIFS_TIMER_FIRED);
            call ChannelMonitor.start();
        }
        else {
            storeOldState(93);
            signalFailure(10);
        }
    }
    
    /****** ChannelMonitor events *********************/

    async event void ChannelMonitor.channelBusy() {
        atomic {
            if(macState == CCA) {
                storeOldState(100);
                macState = RX;
                signalMacState();
                setFlag(&flags, BUSY_DETECTED_VIA_RSSI);
                updateRetryCounters();
                call Timer.start(backoff());
            }
            else if(macState == RX_P) {
                storeOldState(101);
                setFlag(&flags, BUSY_DETECTED_VIA_RSSI);
            }
            else if((macState == RX) && (isFlagSet(&flags, CHECK_RX_LIVENESS))) {
                storeOldState(102);
                call Timer.start(CHECK_RX_LIVENESS_INTERVALL);
            }
        }
    }

    async event void ChannelMonitor.channelIdle() {
        storeOldState(110);
        if((macState == RX) && (isFlagSet(&flags, CHECK_RX_LIVENESS))) {
                storeOldState(111);
                clearFlag(&flags, CHECK_RX_LIVENESS);
                call Timer.start(backoff());
        }
        else if(macState == CCA) {
          if(isFlagSet(&flags, DIFS_TIMER_FIRED)) {    
            clearFlag(&flags, DIFS_TIMER_FIRED);
            storeOldState(112);
            macState = SW_TX;
            signalMacState();
            setTxMode();
          }
        }
    }


    /****** ChannelMonitorControl events **************/
    
    event void ChannelMonitorControl.updateNoiseFloorDone() {
        if(macState == INIT) {
            storeOldState(120);
            macState = RX;
            signalMacState();
            post StartDoneTask();
        } else {
            storeOldState(121);
            signalFailure(11);
        }
    }

    /***** ChannelMonitorData events ******************/
    
    async event void ChannelMonitorData.getSnrDone(int16_t data) {
        atomic if(macState == RX_P) rssiValue = data;
    }

    
    /***** unused Radio Modes events **************************/
    
    async event void RadioModes.TimerModeDone() {}
    async event void RadioModes.SleepModeDone() {}
    async event void RadioModes.SelfPollingModeDone() {}
    async event void RadioModes.PWDDDInterrupt() {}
}