csmamacp.nc
来自「tinyos-2.x.rar」· NC 代码 · 共 999 行 · 第 1/2 页
NC
999 行
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 ) {
if((macState == TX) && (p_msg == txBufPtr)) {
// to do
}
}
/***** 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() {}
}
⌨️ 快捷键说明
复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?