radio_accnoise.pc

simulator for ad hoc

                //
                case RADIO_SENSING: {
                    //
                    // If the signal power is strong enough, lock the signal and
                    // change the mode to receiving.
                    //
                    if ((propInfo->rxPower_mW >= thisRadio->rxThreshold_mW) &&
                        (propInfo->rxPower_mW >= (accnoise->noisePower_mW *
                                                  accnoise->radioRxSnrThreshold)))
                    {
                        RadioAccnoiseLockPacket(accnoise, msg);
                        accnoise->previousMode = accnoise->mode;
                        accnoise->mode = RADIO_RECEIVING;
                        receivingNewSignal = TRUE;
                        RadioAccnoiseReportExtendedStatusToMac(
                            node,
                            radioNum,
                            RADIO_RECEIVING,
                            txDuration,
                            msg);
                    }
                    //
                    // If not, add it to the accumulated noise.
                    // The radio mode stays sensing.
                    //
                    else {
                        accnoise->noisePower_mW += propInfo->rxPower_mW;
                    }
                    
                    break;
                }
                //
                // If the radio is receiving, check if the arrived signal can
                // be captured or collied with the receiving signal.
                //
                case RADIO_RECEIVING: {
                    //
                    // If the radio type is BER_BASED, check if the receiving
                    // signal has been dropped.
                    //
                    if (accnoise->radioRxType == BER_BASED) {
                        BOOL errorOccurred =
                            RadioAccnoiseCheckRxPacketError(node, radioNum);

                        if (errorOccurred == TRUE) {
                            RadioAccnoiseUnlockPacket(node, accnoise);
                            accnoise->previousMode = accnoise->mode;
                            accnoise->mode = RADIO_SENSING;
                        }
                        else {
                            accnoise->rxStartTime = simclock();
                        }
                    }

                    //
                    // Check if the arrived packet can be captured.
                    //
                    if (propInfo->rxPower_mW >= ((accnoise->noisePower_mW +
                                                  accnoise->rxMsgPower_mW) *
                                                 accnoise->radioRxSnrThreshold))
                    {
                        RadioAccnoiseUnlockPacket(node, accnoise);
                        RadioAccnoiseLockPacket(accnoise, msg);
                        accnoise->previousMode = accnoise->mode;
                        accnoise->mode = RADIO_RECEIVING;
                        receivingNewSignal = TRUE;
                        

                        RadioAccnoiseReportExtendedStatusToMac(
                            node,
                            radioNum,
                            RADIO_RECEIVING,
                            txDuration,
                            msg);
                    }
                    //
                    // Check if the arrived packet can be collied with the
                    // receiving signal.
                    // This check is only for SNR_BOUNDED as the error
                    // (collision) from now till the next noise level change
                    // will be evaluated later in BER_BASED.
                    //
                    else {
                        accnoise->noisePower_mW += propInfo->rxPower_mW;

                        if (accnoise->radioRxType == SNR_BOUNDED &&
                            accnoise->rxMsgPower_mW <
                            (accnoise->noisePower_mW *
                             accnoise->radioRxSnrThreshold))
                        {
                            RadioAccnoiseUnlockPacket(node, accnoise);
                            accnoise->previousMode = accnoise->mode;
                            accnoise->mode = RADIO_SENSING;
                            accnoise->stats.totalCollisions++;
                        }
                    }                        

                    if (accnoise->mode == RADIO_SENSING) {
                        RadioAccnoiseReportStatusToMac(node,
                                                      radioNum,
                                                      RADIO_SENSING);
                    }

                    break;
                }

                default:
                    assert(FALSE);
            }

            //
            // Statistics
            //
            if (propInfo->rxPower_mW >= thisRadio->rxSensitivity_mW) {
                accnoise->stats.totalRxSignalsAboveCS++;
            }
            if (propInfo->rxPower_mW >= thisRadio->rxThreshold_mW) {
                accnoise->stats.totalRxSignalsAboveRX++;
            }

            GLOMO_MsgSetInstanceId(msg, radioNum);
            GLOMO_MsgSetEvent(msg, MSG_RADIO_FromChannelEnd);
            GLOMO_MsgSend(node, msg, txDuration);

            //
            // Increment number of packets currently being processed.
            //
            accnoise->numSignals++;
            assert(accnoise->numSignals >= 1);

                           
           
            
                

            break;
        }

        //
        // Radio signal end
        //
        case MSG_RADIO_FromChannelEnd: {
            PropInfo *propInfo = (PropInfo *)GLOMO_MsgReturnInfo(msg);
            BOOL noiseSignalStopped = FALSE;

            
            if (propInfo->correlatedFastFading_dB != 0.0) {                               
                accnoise->lastReceivedFrameFastFading_dB = 
                    propInfo->correlatedFastFading_dB;
                accnoise->lastReceivedFrameSourceNode = propInfo->txAddr;
                accnoise->lastReceivedFrameTime = simclock();
            }//if//
            
            //
            // If the BER_BASED radio is in the receiving mode, check if the
            // receiving signal has been dropped.
            //
            if (accnoise->mode == RADIO_RECEIVING &&
                accnoise->radioRxType == BER_BASED)
            {
                BOOL errorOccurred =
                    RadioAccnoiseCheckRxPacketError(node, radioNum);

                if (errorOccurred == TRUE) {
                    RadioAccnoiseUnlockPacket(node, accnoise);
                    accnoise->previousMode = accnoise->mode;
                    accnoise->mode = RADIO_SENSING;

                    RadioAccnoiseReportStatusToMac(node,
                                                  radioNum,
                                                  RADIO_SENSING);
                }
                else {
                    accnoise->rxStartTime = simclock();
                }
            }

            //
            // If the radio is still receiving this signal, forward the frame
            // to the MAC layer.
            //
            if (accnoise->mode == RADIO_RECEIVING && accnoise->rxMsg == msg) {
                if (thisRadio->guiOption == TRUE) {
                    RadioAccnoiseGuiDrawLine(propInfo->txAddr,
                                            node->nodeAddr,
                                            TRUE);
                }

                /*
                 * Success! No longer locking onto the packet
                 */
                
                accnoise->rxMsg = NULL;
                accnoise->rxMsgPower_mW = 0.0;
                accnoise->rxStartTime = 0;
                
                if (accnoise->noisePower_mW > thisRadio->rxSensitivity_mW) {
                    accnoise->previousMode = accnoise->mode;
                    accnoise->mode = RADIO_SENSING;
                }
                else {
                    accnoise->previousMode = accnoise->mode;
                    accnoise->mode = RADIO_IDLE;
                }

                assert(msg->error == FALSE);
               
                GLOMO_MacReceivePacketFromRadio(
                    node, node->radioData[radioNum]->macInterfaceIndex, msg);

                accnoise->stats.totalRxSignalsToMac++;
            }
            else {
                if (thisRadio->guiOption == TRUE) {
                    RadioAccnoiseGuiDrawLine(propInfo->txAddr,
                                            node->nodeAddr,
                                            FALSE);
                }

                accnoise->noisePower_mW -= propInfo->rxPower_mW; 
                noiseSignalStopped = TRUE;

                if (accnoise->mode == RADIO_SENSING &&
                    accnoise->noisePower_mW <= thisRadio->rxSensitivity_mW)
                {
                    accnoise->previousMode = accnoise->mode;
                    accnoise->mode = RADIO_IDLE;

                    RadioAccnoiseReportStatusToMac(node,
                                                  radioNum,
                                                  RADIO_IDLE);
                }

                GLOMO_MsgFree(node, msg);
            }


            //
            // Decrement the number of packets being sensed.
            //
            accnoise->numSignals--;
            assert(accnoise->numSignals >= 0);
            
            
            
            
            //
            // Avoid rounding error in the accumulated noise value.
            //
            if (accnoise->numSignals == 0) {
                double noise_mW = thisRadio->backgroundNoise_mW;

                //
                // Sanity check.
                //
                if (fabs((double)(accnoise->noisePower_mW - noise_mW))
                    >= 1.0e-13)
                {
                    assert(FALSE); abort();
                }

                accnoise->noisePower_mW = noise_mW;
            }

            break;
        }

        case MSG_RADIO_StartPropagation: {
            PropInfo *propInfo = (PropInfo *)GLOMO_MsgReturnInfo(msg);

            assert(accnoise->mode == RADIO_TRANSMITTING);

            GLOMO_PropBroadcast(node->partitionData, msg);
            
            GLOMO_MsgSetInstanceId(msg, radioNum);
            GLOMO_MsgSetLayer(msg, GLOMO_RADIO_LAYER, 0);
            GLOMO_MsgSetEvent(msg, MSG_RADIO_SwitchToIdle);
            GLOMO_MsgSend(node, msg, propInfo->txDuration);

            break;
        }

        case MSG_RADIO_SwitchToIdle: {
            assert(accnoise->mode == RADIO_TRANSMITTING);

            if (accnoise->noisePower_mW > thisRadio->rxSensitivity_mW) {
                accnoise->previousMode = accnoise->mode;
                accnoise->mode = RADIO_SENSING;
            }
            else {
                accnoise->previousMode = accnoise->mode;
                accnoise->mode = RADIO_IDLE;
            }
            RadioAccnoiseReportStatusToMac(node, radioNum, accnoise->mode);
            GLOMO_MsgFree(node, msg);
            
            
            
            break;
        }

        /*
         * Mac Layer asking radio to check channel status
         * (Carrier Sensing)
         */
        case MSG_RADIO_CheckChannelStatus: {
            assert(FALSE); abort(); 
            GLOMO_MsgFree(node, msg);

            RadioAccnoiseReportStatusToMac(node, radioNum, accnoise->mode);
            break;
        }

        default: {
            char clockStr[GLOMO_MAX_STRING_LENGTH];
            ctoa(simclock(), clockStr);
            printf("Time %s: Node %u received message of unknown type %d.\n",
                    clockStr, node->nodeAddr, msg->eventType);
            assert(FALSE);
        }
    }
}


void RadioAccnoiseFinalize(GlomoNode *node, const int radioNum) {
    GlomoRadio* thisRadio = node->radioData[radioNum];
    GlomoRadioAccnoise* accnoise = thisRadio->radioVar;
    char buf[100];

    if (thisRadio->radioStats == FALSE) {
        return;
    }

    assert(thisRadio->radioStats == TRUE);

    sprintf(buf, "Signals transmitted: %d",
            accnoise->stats.totalTxSignals);
    GLOMO_PrintStat(node, "RadioAccnoise", buf);

    sprintf(buf, "Signals arrived with power above RX sensitivity: %d",
            accnoise->stats.totalRxSignalsAboveCS);
    GLOMO_PrintStat(node, "RadioAccnoise", buf);

    sprintf(buf, "Signals arrived with power above RX threshold: %d",
            accnoise->stats.totalRxSignalsAboveRX);
    GLOMO_PrintStat(node, "RadioAccnoise", buf);

    sprintf(buf, "Signals received and forwarded to MAC: %d",
            accnoise->stats.totalRxSignalsToMac);
    GLOMO_PrintStat(node, "RadioAccnoise", buf);

    sprintf(buf, "Collisions: %d",
            accnoise->stats.totalCollisions);
    GLOMO_PrintStat(node, "RadioAccnoise", buf);

    accnoise->stats.energyConsumed
        += BATTERY_RX_POWER * (simclock() - accnoise->stats.turnOnTime);

    sprintf(buf, "Energy consumption (in mWhr): %.3f",
            accnoise->stats.energyConsumed / 3600.0);
    GLOMO_PrintStat(node, "RadioAccnoise", buf);
}


BOOL RadioAccnoiseCheckRxPacketError(GlomoNode *node, int radioNum) {
    double BER;
    GlomoRadio* thisRadio = node->radioData[radioNum];
    GlomoRadioAccnoise *accnoise = thisRadio->radioVar;

    //
    // Get BER from the fading model
    //
    BER = GLOMO_PropBER(node, accnoise->rxMsgPower_mW, accnoise->noisePower_mW);

    if (BER != 0.0) {
        double numBits = ((double)(simclock() - accnoise->rxStartTime)
                          * (double)thisRadio->bandwidth / (double)SECOND);

        double errorProbability = 1.0 - pow((1.0 - BER), numBits);

        assert((errorProbability >= 0.0) && (errorProbability <= 1.0));

        if (errorProbability > pc_erand(node->seed)) {
            return TRUE;
        }
    }

    return FALSE;
}

void RadioAccnoiseGuiDrawLine(NODE_ADDR sourceAddr, NODE_ADDR destAddr, BOOL success) {
    JGUI_COLOR failTxColor, successTxColor;
    char simTime[50];
                    
    ctoa(simclock(), simTime);
    failTxColor = JGUI_RED;
    successTxColor = JGUI_GREEN;

    JGUI_EraseLink(sourceAddr, destAddr, simTime);

    if (success == TRUE) {
        JGUI_DrawLine(sourceAddr, destAddr, simTime, successTxColor);
    }
    else {
        JGUI_DrawLine(sourceAddr, destAddr, simTime, failTxColor);
    }
}